--- /srv/reproducible-results/rbuild-debian/r-b-build.2vi0Kz12/b1/golang-github-tinylib-msgp_1.0.2-3_amd64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.2vi0Kz12/b2/golang-github-tinylib-msgp_1.0.2-3_amd64.changes ├── Files │ @@ -1,3 +1,3 @@ │ │ - c55fa2eba1706f9c75566c9bbacbad4e 69224 devel optional golang-github-tinylib-msgp-dev_1.0.2-3_all.deb │ + db7c2e5cb10f920579db2c5eb6246132 69488 devel optional golang-github-tinylib-msgp-dev_1.0.2-3_all.deb │ 5adfbe72d7170f90194de9feb3eedab5 1422828 devel optional msgp_1.0.2-3_amd64.deb ├── golang-github-tinylib-msgp-dev_1.0.2-3_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2020-04-11 06:26:55.000000 debian-binary │ │ -rw-r--r-- 0 0 0 2248 2020-04-11 06:26:55.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 66784 2020-04-11 06:26:55.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 67048 2020-04-11 06:26:55.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./control │ │ │ │ @@ -1,13 +1,13 @@ │ │ │ │ Package: golang-github-tinylib-msgp-dev │ │ │ │ Source: golang-github-tinylib-msgp │ │ │ │ Version: 1.0.2-3 │ │ │ │ Architecture: all │ │ │ │ Maintainer: Debian Go Packaging Team │ │ │ │ -Installed-Size: 455 │ │ │ │ +Installed-Size: 458 │ │ │ │ Depends: golang-github-philhofer-fwd-dev, golang-github-ttacon-chalk-dev, golang-golang-x-mod-dev, golang-golang-x-tools-dev │ │ │ │ Section: devel │ │ │ │ Priority: optional │ │ │ │ Homepage: https://github.com/tinylib/msgp │ │ │ │ Description: Go code generator for MessagePack (source) │ │ │ │ This is a code generation tool and serialization library for MessagePack. It is │ │ │ │ targeted at the go generate tool. You can read more about MessagePack in the │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -9,15 +9,15 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 4325 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/def.go │ │ │ │ -rw-r--r-- 0 root (0) root (0) 3013 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/gen_test.go │ │ │ │ --rw-r--r-- 0 root (0) root (0) 94415 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/generated.go │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 97626 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/generated.go │ │ │ │ -rw-r--r-- 0 root (0) root (0) 39740 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/generated_test.go │ │ │ │ -rw-r--r-- 0 root (0) root (0) 629 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/issue94.go │ │ │ │ -rw-r--r-- 0 root (0) root (0) 2060 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/issue94_gen.go │ │ │ │ -rw-r--r-- 0 root (0) root (0) 2237 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/issue94_gen_test.go │ │ │ │ -rwxr-xr-x 0 root (0) root (0) 172 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/search.sh │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/gen/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 4279 2020-04-11 06:26:55.000000 ./usr/share/gocode/src/github.com/tinylib/msgp/gen/decode.go │ │ │ ├── ./usr/share/gocode/src/github.com/tinylib/msgp/_generated/generated.go │ │ │ │ @@ -146,50 +146,50 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Custom) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zhct uint32 │ │ │ │ - zhct, err = dc.ReadMapHeader() │ │ │ │ + var zcua uint32 │ │ │ │ + zcua, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zhct > 0 { │ │ │ │ - zhct-- │ │ │ │ + for zcua > 0 { │ │ │ │ + zcua-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "bts": │ │ │ │ { │ │ │ │ - var zcua []byte │ │ │ │ - zcua, err = dc.ReadBytes([]byte(z.Bts)) │ │ │ │ - z.Bts = CustomBytes(zcua) │ │ │ │ + var zxhx []byte │ │ │ │ + zxhx, err = dc.ReadBytes([]byte(z.Bts)) │ │ │ │ + z.Bts = CustomBytes(zxhx) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "mp": │ │ │ │ - var zxhx uint32 │ │ │ │ - zxhx, err = dc.ReadMapHeader() │ │ │ │ + var zlqf uint32 │ │ │ │ + zlqf, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z.Mp == nil && zxhx > 0 { │ │ │ │ - z.Mp = make(map[string]*Embedded, zxhx) │ │ │ │ + if z.Mp == nil && zlqf > 0 { │ │ │ │ + z.Mp = make(map[string]*Embedded, zlqf) │ │ │ │ } else if len(z.Mp) > 0 { │ │ │ │ for key, _ := range z.Mp { │ │ │ │ delete(z.Mp, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zxhx > 0 { │ │ │ │ - zxhx-- │ │ │ │ + for zlqf > 0 { │ │ │ │ + zlqf-- │ │ │ │ var zcmr string │ │ │ │ var zajw *Embedded │ │ │ │ zcmr, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ if dc.IsNil() { │ │ │ │ @@ -206,39 +206,88 @@ │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ z.Mp[zcmr] = zajw │ │ │ │ } │ │ │ │ case "enums": │ │ │ │ - var zlqf uint32 │ │ │ │ - zlqf, err = dc.ReadArrayHeader() │ │ │ │ + var zdaf uint32 │ │ │ │ + zdaf, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Enums) >= int(zlqf) { │ │ │ │ - z.Enums = (z.Enums)[:zlqf] │ │ │ │ + if cap(z.Enums) >= int(zdaf) { │ │ │ │ + z.Enums = (z.Enums)[:zdaf] │ │ │ │ } else { │ │ │ │ - z.Enums = make([]MyEnum, zlqf) │ │ │ │ + z.Enums = make([]MyEnum, zdaf) │ │ │ │ } │ │ │ │ for zwht := range z.Enums { │ │ │ │ { │ │ │ │ - var zdaf string │ │ │ │ - zdaf, err = dc.ReadString() │ │ │ │ - z.Enums[zwht] = myenumStr(zdaf) │ │ │ │ + var zpks string │ │ │ │ + zpks, err = dc.ReadString() │ │ │ │ + z.Enums[zwht] = myenumStr(zpks) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Some": │ │ │ │ - err = z.Some.DecodeMsg(dc) │ │ │ │ + var zjfb uint32 │ │ │ │ + zjfb, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ + for zjfb > 0 { │ │ │ │ + zjfb-- │ │ │ │ + field, err = dc.ReadMapKeyPtr() │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + switch msgp.UnsafeString(field) { │ │ │ │ + case "files": │ │ │ │ + var zcxo uint32 │ │ │ │ + zcxo, err = dc.ReadArrayHeader() │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if cap(z.Some.Relevent) >= int(zcxo) { │ │ │ │ + z.Some.Relevent = (z.Some.Relevent)[:zcxo] │ │ │ │ + } else { │ │ │ │ + z.Some.Relevent = make(Files, zcxo) │ │ │ │ + } │ │ │ │ + for zhct := range z.Some.Relevent { │ │ │ │ + if dc.IsNil() { │ │ │ │ + err = dc.ReadNil() │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + z.Some.Relevent[zhct] = nil │ │ │ │ + } else { │ │ │ │ + { │ │ │ │ + var zeff string │ │ │ │ + zeff, err = dc.ReadString() │ │ │ │ + z.Some.Relevent[zhct] = filefromstr(zeff) │ │ │ │ + } │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + case "name": │ │ │ │ + z.Some.Name, err = dc.ReadString() │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + default: │ │ │ │ + err = dc.Skip() │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ default: │ │ │ │ err = dc.Skip() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ @@ -295,19 +344,43 @@ │ │ │ │ for zwht := range z.Enums { │ │ │ │ err = en.WriteString((MyEnum).String(z.Enums[zwht])) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "Some" │ │ │ │ - err = en.Append(0xa4, 0x53, 0x6f, 0x6d, 0x65) │ │ │ │ + // map header, size 2 │ │ │ │ + // write "files" │ │ │ │ + err = en.Append(0xa4, 0x53, 0x6f, 0x6d, 0x65, 0x82, 0xa5, 0x66, 0x69, 0x6c, 0x65, 0x73) │ │ │ │ + if err != nil { │ │ │ │ + return err │ │ │ │ + } │ │ │ │ + err = en.WriteArrayHeader(uint32(len(z.Some.Relevent))) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + for zhct := range z.Some.Relevent { │ │ │ │ + if z.Some.Relevent[zhct] == nil { │ │ │ │ + err = en.WriteNil() │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + } else { │ │ │ │ + err = en.WriteString(filetostr(z.Some.Relevent[zhct])) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + // write "name" │ │ │ │ + err = en.Append(0xa4, 0x6e, 0x61, 0x6d, 0x65) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ - err = z.Some.EncodeMsg(en) │ │ │ │ + err = en.WriteString(z.Some.Name) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // MarshalMsg implements msgp.Marshaler │ │ │ │ @@ -334,64 +407,73 @@ │ │ │ │ // string "enums" │ │ │ │ o = append(o, 0xa5, 0x65, 0x6e, 0x75, 0x6d, 0x73) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Enums))) │ │ │ │ for zwht := range z.Enums { │ │ │ │ o = msgp.AppendString(o, (MyEnum).String(z.Enums[zwht])) │ │ │ │ } │ │ │ │ // string "Some" │ │ │ │ - o = append(o, 0xa4, 0x53, 0x6f, 0x6d, 0x65) │ │ │ │ - o, err = z.Some.MarshalMsg(o) │ │ │ │ - if err != nil { │ │ │ │ - return │ │ │ │ + // map header, size 2 │ │ │ │ + // string "files" │ │ │ │ + o = append(o, 0xa4, 0x53, 0x6f, 0x6d, 0x65, 0x82, 0xa5, 0x66, 0x69, 0x6c, 0x65, 0x73) │ │ │ │ + o = msgp.AppendArrayHeader(o, uint32(len(z.Some.Relevent))) │ │ │ │ + for zhct := range z.Some.Relevent { │ │ │ │ + if z.Some.Relevent[zhct] == nil { │ │ │ │ + o = msgp.AppendNil(o) │ │ │ │ + } else { │ │ │ │ + o = msgp.AppendString(o, filetostr(z.Some.Relevent[zhct])) │ │ │ │ + } │ │ │ │ } │ │ │ │ + // string "name" │ │ │ │ + o = append(o, 0xa4, 0x6e, 0x61, 0x6d, 0x65) │ │ │ │ + o = msgp.AppendString(o, z.Some.Name) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Custom) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zpks uint32 │ │ │ │ - zpks, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zrsw uint32 │ │ │ │ + zrsw, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zpks > 0 { │ │ │ │ - zpks-- │ │ │ │ + for zrsw > 0 { │ │ │ │ + zrsw-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "bts": │ │ │ │ { │ │ │ │ - var zjfb []byte │ │ │ │ - zjfb, bts, err = msgp.ReadBytesBytes(bts, []byte(z.Bts)) │ │ │ │ - z.Bts = CustomBytes(zjfb) │ │ │ │ + var zxpk []byte │ │ │ │ + zxpk, bts, err = msgp.ReadBytesBytes(bts, []byte(z.Bts)) │ │ │ │ + z.Bts = CustomBytes(zxpk) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "mp": │ │ │ │ - var zcxo uint32 │ │ │ │ - zcxo, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zdnj uint32 │ │ │ │ + zdnj, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z.Mp == nil && zcxo > 0 { │ │ │ │ - z.Mp = make(map[string]*Embedded, zcxo) │ │ │ │ + if z.Mp == nil && zdnj > 0 { │ │ │ │ + z.Mp = make(map[string]*Embedded, zdnj) │ │ │ │ } else if len(z.Mp) > 0 { │ │ │ │ for key, _ := range z.Mp { │ │ │ │ delete(z.Mp, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zcxo > 0 { │ │ │ │ + for zdnj > 0 { │ │ │ │ var zcmr string │ │ │ │ var zajw *Embedded │ │ │ │ - zcxo-- │ │ │ │ + zdnj-- │ │ │ │ zcmr, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ bts, err = msgp.ReadNilBytes(bts) │ │ │ │ if err != nil { │ │ │ │ @@ -406,39 +488,88 @@ │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ z.Mp[zcmr] = zajw │ │ │ │ } │ │ │ │ case "enums": │ │ │ │ - var zeff uint32 │ │ │ │ - zeff, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zobc uint32 │ │ │ │ + zobc, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Enums) >= int(zeff) { │ │ │ │ - z.Enums = (z.Enums)[:zeff] │ │ │ │ + if cap(z.Enums) >= int(zobc) { │ │ │ │ + z.Enums = (z.Enums)[:zobc] │ │ │ │ } else { │ │ │ │ - z.Enums = make([]MyEnum, zeff) │ │ │ │ + z.Enums = make([]MyEnum, zobc) │ │ │ │ } │ │ │ │ for zwht := range z.Enums { │ │ │ │ { │ │ │ │ - var zrsw string │ │ │ │ - zrsw, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ - z.Enums[zwht] = myenumStr(zrsw) │ │ │ │ + var zsnv string │ │ │ │ + zsnv, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + z.Enums[zwht] = myenumStr(zsnv) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Some": │ │ │ │ - bts, err = z.Some.UnmarshalMsg(bts) │ │ │ │ + var zkgt uint32 │ │ │ │ + zkgt, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ + for zkgt > 0 { │ │ │ │ + zkgt-- │ │ │ │ + field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + switch msgp.UnsafeString(field) { │ │ │ │ + case "files": │ │ │ │ + var zema uint32 │ │ │ │ + zema, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + if cap(z.Some.Relevent) >= int(zema) { │ │ │ │ + z.Some.Relevent = (z.Some.Relevent)[:zema] │ │ │ │ + } else { │ │ │ │ + z.Some.Relevent = make(Files, zema) │ │ │ │ + } │ │ │ │ + for zhct := range z.Some.Relevent { │ │ │ │ + if msgp.IsNil(bts) { │ │ │ │ + bts, err = msgp.ReadNilBytes(bts) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + z.Some.Relevent[zhct] = nil │ │ │ │ + } else { │ │ │ │ + { │ │ │ │ + var zpez string │ │ │ │ + zpez, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + z.Some.Relevent[zhct] = filefromstr(zpez) │ │ │ │ + } │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ + case "name": │ │ │ │ + z.Some.Name, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + default: │ │ │ │ + bts, err = msgp.Skip(bts) │ │ │ │ + if err != nil { │ │ │ │ + return │ │ │ │ + } │ │ │ │ + } │ │ │ │ + } │ │ │ │ default: │ │ │ │ bts, err = msgp.Skip(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ @@ -460,24 +591,32 @@ │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ s += 6 + msgp.ArrayHeaderSize │ │ │ │ for zwht := range z.Enums { │ │ │ │ s += msgp.StringPrefixSize + len((MyEnum).String(z.Enums[zwht])) │ │ │ │ } │ │ │ │ - s += 5 + z.Some.Msgsize() │ │ │ │ + s += 5 + 1 + 6 + msgp.ArrayHeaderSize │ │ │ │ + for zhct := range z.Some.Relevent { │ │ │ │ + if z.Some.Relevent[zhct] == nil { │ │ │ │ + s += msgp.NilSize │ │ │ │ + } else { │ │ │ │ + s += msgp.StringPrefixSize + len(filetostr(z.Some.Relevent[zhct])) │ │ │ │ + } │ │ │ │ + } │ │ │ │ + s += 5 + msgp.StringPrefixSize + len(z.Some.Name) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *CustomBytes) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zxpk []byte │ │ │ │ - zxpk, err = dc.ReadBytes([]byte((*z))) │ │ │ │ - (*z) = CustomBytes(zxpk) │ │ │ │ + var zqke []byte │ │ │ │ + zqke, err = dc.ReadBytes([]byte((*z))) │ │ │ │ + (*z) = CustomBytes(zqke) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -496,17 +635,17 @@ │ │ │ │ o = msgp.AppendBytes(o, []byte(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *CustomBytes) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zdnj []byte │ │ │ │ - zdnj, bts, err = msgp.ReadBytesBytes(bts, []byte((*z))) │ │ │ │ - (*z) = CustomBytes(zdnj) │ │ │ │ + var zqyh []byte │ │ │ │ + zqyh, bts, err = msgp.ReadBytesBytes(bts, []byte((*z))) │ │ │ │ + (*z) = CustomBytes(zqyh) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -516,17 +655,17 @@ │ │ │ │ s = msgp.BytesPrefixSize + len([]byte(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *CustomInt) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zobc int │ │ │ │ - zobc, err = dc.ReadInt() │ │ │ │ - (*z) = CustomInt(zobc) │ │ │ │ + var zyzr int │ │ │ │ + zyzr, err = dc.ReadInt() │ │ │ │ + (*z) = CustomInt(zyzr) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -545,17 +684,17 @@ │ │ │ │ o = msgp.AppendInt(o, int(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *CustomInt) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zsnv int │ │ │ │ - zsnv, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ - (*z) = CustomInt(zsnv) │ │ │ │ + var zywj int │ │ │ │ + zywj, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ + (*z) = CustomInt(zywj) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -566,21 +705,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Embedded) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zpez uint32 │ │ │ │ - zpez, err = dc.ReadMapHeader() │ │ │ │ + var zrfe uint32 │ │ │ │ + zrfe, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zpez > 0 { │ │ │ │ - zpez-- │ │ │ │ + for zrfe > 0 { │ │ │ │ + zrfe-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Embedded": │ │ │ │ if dc.IsNil() { │ │ │ │ @@ -595,53 +734,53 @@ │ │ │ │ } │ │ │ │ err = z.Embedded.DecodeMsg(dc) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Children": │ │ │ │ - var zqke uint32 │ │ │ │ - zqke, err = dc.ReadArrayHeader() │ │ │ │ + var zgmo uint32 │ │ │ │ + zgmo, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Children) >= int(zqke) { │ │ │ │ - z.Children = (z.Children)[:zqke] │ │ │ │ + if cap(z.Children) >= int(zgmo) { │ │ │ │ + z.Children = (z.Children)[:zgmo] │ │ │ │ } else { │ │ │ │ - z.Children = make([]Embedded, zqke) │ │ │ │ + z.Children = make([]Embedded, zgmo) │ │ │ │ } │ │ │ │ - for zkgt := range z.Children { │ │ │ │ - err = z.Children[zkgt].DecodeMsg(dc) │ │ │ │ + for zjpj := range z.Children { │ │ │ │ + err = z.Children[zjpj].DecodeMsg(dc) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "PtrChildren": │ │ │ │ - var zqyh uint32 │ │ │ │ - zqyh, err = dc.ReadArrayHeader() │ │ │ │ + var ztaf uint32 │ │ │ │ + ztaf, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.PtrChildren) >= int(zqyh) { │ │ │ │ - z.PtrChildren = (z.PtrChildren)[:zqyh] │ │ │ │ + if cap(z.PtrChildren) >= int(ztaf) { │ │ │ │ + z.PtrChildren = (z.PtrChildren)[:ztaf] │ │ │ │ } else { │ │ │ │ - z.PtrChildren = make([]*Embedded, zqyh) │ │ │ │ + z.PtrChildren = make([]*Embedded, ztaf) │ │ │ │ } │ │ │ │ - for zema := range z.PtrChildren { │ │ │ │ + for zzpf := range z.PtrChildren { │ │ │ │ if dc.IsNil() { │ │ │ │ err = dc.ReadNil() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - z.PtrChildren[zema] = nil │ │ │ │ + z.PtrChildren[zzpf] = nil │ │ │ │ } else { │ │ │ │ - if z.PtrChildren[zema] == nil { │ │ │ │ - z.PtrChildren[zema] = new(Embedded) │ │ │ │ + if z.PtrChildren[zzpf] == nil { │ │ │ │ + z.PtrChildren[zzpf] = new(Embedded) │ │ │ │ } │ │ │ │ - err = z.PtrChildren[zema].DecodeMsg(dc) │ │ │ │ + err = z.PtrChildren[zzpf].DecodeMsg(dc) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "Other": │ │ │ │ z.Other, err = dc.ReadString() │ │ │ │ @@ -682,37 +821,37 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Children))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zkgt := range z.Children { │ │ │ │ - err = z.Children[zkgt].EncodeMsg(en) │ │ │ │ + for zjpj := range z.Children { │ │ │ │ + err = z.Children[zjpj].EncodeMsg(en) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "PtrChildren" │ │ │ │ err = en.Append(0xab, 0x50, 0x74, 0x72, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.PtrChildren))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zema := range z.PtrChildren { │ │ │ │ - if z.PtrChildren[zema] == nil { │ │ │ │ + for zzpf := range z.PtrChildren { │ │ │ │ + if z.PtrChildren[zzpf] == nil { │ │ │ │ err = en.WriteNil() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } else { │ │ │ │ - err = z.PtrChildren[zema].EncodeMsg(en) │ │ │ │ + err = z.PtrChildren[zzpf].EncodeMsg(en) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ // write "Other" │ │ │ │ err = en.Append(0xa5, 0x4f, 0x74, 0x68, 0x65, 0x72) │ │ │ │ @@ -739,28 +878,28 @@ │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // string "Children" │ │ │ │ o = append(o, 0xa8, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Children))) │ │ │ │ - for zkgt := range z.Children { │ │ │ │ - o, err = z.Children[zkgt].MarshalMsg(o) │ │ │ │ + for zjpj := range z.Children { │ │ │ │ + o, err = z.Children[zjpj].MarshalMsg(o) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // string "PtrChildren" │ │ │ │ o = append(o, 0xab, 0x50, 0x74, 0x72, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.PtrChildren))) │ │ │ │ - for zema := range z.PtrChildren { │ │ │ │ - if z.PtrChildren[zema] == nil { │ │ │ │ + for zzpf := range z.PtrChildren { │ │ │ │ + if z.PtrChildren[zzpf] == nil { │ │ │ │ o = msgp.AppendNil(o) │ │ │ │ } else { │ │ │ │ - o, err = z.PtrChildren[zema].MarshalMsg(o) │ │ │ │ + o, err = z.PtrChildren[zzpf].MarshalMsg(o) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ // string "Other" │ │ │ │ o = append(o, 0xa5, 0x4f, 0x74, 0x68, 0x65, 0x72) │ │ │ │ @@ -768,21 +907,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Embedded) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zyzr uint32 │ │ │ │ - zyzr, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zeth uint32 │ │ │ │ + zeth, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zyzr > 0 { │ │ │ │ - zyzr-- │ │ │ │ + for zeth > 0 { │ │ │ │ + zeth-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Embedded": │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ @@ -797,53 +936,53 @@ │ │ │ │ } │ │ │ │ bts, err = z.Embedded.UnmarshalMsg(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Children": │ │ │ │ - var zywj uint32 │ │ │ │ - zywj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zsbz uint32 │ │ │ │ + zsbz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Children) >= int(zywj) { │ │ │ │ - z.Children = (z.Children)[:zywj] │ │ │ │ + if cap(z.Children) >= int(zsbz) { │ │ │ │ + z.Children = (z.Children)[:zsbz] │ │ │ │ } else { │ │ │ │ - z.Children = make([]Embedded, zywj) │ │ │ │ + z.Children = make([]Embedded, zsbz) │ │ │ │ } │ │ │ │ - for zkgt := range z.Children { │ │ │ │ - bts, err = z.Children[zkgt].UnmarshalMsg(bts) │ │ │ │ + for zjpj := range z.Children { │ │ │ │ + bts, err = z.Children[zjpj].UnmarshalMsg(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "PtrChildren": │ │ │ │ - var zjpj uint32 │ │ │ │ - zjpj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zrjx uint32 │ │ │ │ + zrjx, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.PtrChildren) >= int(zjpj) { │ │ │ │ - z.PtrChildren = (z.PtrChildren)[:zjpj] │ │ │ │ + if cap(z.PtrChildren) >= int(zrjx) { │ │ │ │ + z.PtrChildren = (z.PtrChildren)[:zrjx] │ │ │ │ } else { │ │ │ │ - z.PtrChildren = make([]*Embedded, zjpj) │ │ │ │ + z.PtrChildren = make([]*Embedded, zrjx) │ │ │ │ } │ │ │ │ - for zema := range z.PtrChildren { │ │ │ │ + for zzpf := range z.PtrChildren { │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ bts, err = msgp.ReadNilBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - z.PtrChildren[zema] = nil │ │ │ │ + z.PtrChildren[zzpf] = nil │ │ │ │ } else { │ │ │ │ - if z.PtrChildren[zema] == nil { │ │ │ │ - z.PtrChildren[zema] = new(Embedded) │ │ │ │ + if z.PtrChildren[zzpf] == nil { │ │ │ │ + z.PtrChildren[zzpf] = new(Embedded) │ │ │ │ } │ │ │ │ - bts, err = z.PtrChildren[zema].UnmarshalMsg(bts) │ │ │ │ + bts, err = z.PtrChildren[zzpf].UnmarshalMsg(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "Other": │ │ │ │ z.Other, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ @@ -866,40 +1005,40 @@ │ │ │ │ s = 1 + 9 │ │ │ │ if z.Embedded == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ s += z.Embedded.Msgsize() │ │ │ │ } │ │ │ │ s += 9 + msgp.ArrayHeaderSize │ │ │ │ - for zkgt := range z.Children { │ │ │ │ - s += z.Children[zkgt].Msgsize() │ │ │ │ + for zjpj := range z.Children { │ │ │ │ + s += z.Children[zjpj].Msgsize() │ │ │ │ } │ │ │ │ s += 12 + msgp.ArrayHeaderSize │ │ │ │ - for zema := range z.PtrChildren { │ │ │ │ - if z.PtrChildren[zema] == nil { │ │ │ │ + for zzpf := range z.PtrChildren { │ │ │ │ + if z.PtrChildren[zzpf] == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ - s += z.PtrChildren[zema].Msgsize() │ │ │ │ + s += z.PtrChildren[zzpf].Msgsize() │ │ │ │ } │ │ │ │ } │ │ │ │ s += 6 + msgp.StringPrefixSize + len(z.Other) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *FastAlias) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zzpf uint32 │ │ │ │ - zzpf, err = dc.ReadMapHeader() │ │ │ │ + var zawn uint32 │ │ │ │ + zawn, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zzpf > 0 { │ │ │ │ - zzpf-- │ │ │ │ + for zawn > 0 { │ │ │ │ + zawn-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Lat": │ │ │ │ z.Lat, err = dc.ReadFloat64() │ │ │ │ @@ -992,21 +1131,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *FastAlias) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zrfe uint32 │ │ │ │ - zrfe, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zwel uint32 │ │ │ │ + zwel, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zrfe > 0 { │ │ │ │ - zrfe-- │ │ │ │ + for zwel > 0 { │ │ │ │ + zwel-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Lat": │ │ │ │ z.Lat, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ @@ -1045,49 +1184,49 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *FileHandle) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var ztaf uint32 │ │ │ │ - ztaf, err = dc.ReadMapHeader() │ │ │ │ + var zmfd uint32 │ │ │ │ + zmfd, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for ztaf > 0 { │ │ │ │ - ztaf-- │ │ │ │ + for zmfd > 0 { │ │ │ │ + zmfd-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "files": │ │ │ │ - var zeth uint32 │ │ │ │ - zeth, err = dc.ReadArrayHeader() │ │ │ │ + var zzdc uint32 │ │ │ │ + zzdc, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Relevent) >= int(zeth) { │ │ │ │ - z.Relevent = (z.Relevent)[:zeth] │ │ │ │ + if cap(z.Relevent) >= int(zzdc) { │ │ │ │ + z.Relevent = (z.Relevent)[:zzdc] │ │ │ │ } else { │ │ │ │ - z.Relevent = make(Files, zeth) │ │ │ │ + z.Relevent = make(Files, zzdc) │ │ │ │ } │ │ │ │ - for zgmo := range z.Relevent { │ │ │ │ + for zrbe := range z.Relevent { │ │ │ │ if dc.IsNil() { │ │ │ │ err = dc.ReadNil() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - z.Relevent[zgmo] = nil │ │ │ │ + z.Relevent[zrbe] = nil │ │ │ │ } else { │ │ │ │ { │ │ │ │ - var zsbz string │ │ │ │ - zsbz, err = dc.ReadString() │ │ │ │ - z.Relevent[zgmo] = filefromstr(zsbz) │ │ │ │ + var zelx string │ │ │ │ + zelx, err = dc.ReadString() │ │ │ │ + z.Relevent[zrbe] = filefromstr(zelx) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "name": │ │ │ │ @@ -1113,22 +1252,22 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Relevent))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zgmo := range z.Relevent { │ │ │ │ - if z.Relevent[zgmo] == nil { │ │ │ │ + for zrbe := range z.Relevent { │ │ │ │ + if z.Relevent[zrbe] == nil { │ │ │ │ err = en.WriteNil() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } else { │ │ │ │ - err = en.WriteString(filetostr(z.Relevent[zgmo])) │ │ │ │ + err = en.WriteString(filetostr(z.Relevent[zrbe])) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ // write "name" │ │ │ │ err = en.Append(0xa4, 0x6e, 0x61, 0x6d, 0x65) │ │ │ │ @@ -1145,66 +1284,66 @@ │ │ │ │ // MarshalMsg implements msgp.Marshaler │ │ │ │ func (z *FileHandle) MarshalMsg(b []byte) (o []byte, err error) { │ │ │ │ o = msgp.Require(b, z.Msgsize()) │ │ │ │ // map header, size 2 │ │ │ │ // string "files" │ │ │ │ o = append(o, 0x82, 0xa5, 0x66, 0x69, 0x6c, 0x65, 0x73) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Relevent))) │ │ │ │ - for zgmo := range z.Relevent { │ │ │ │ - if z.Relevent[zgmo] == nil { │ │ │ │ + for zrbe := range z.Relevent { │ │ │ │ + if z.Relevent[zrbe] == nil { │ │ │ │ o = msgp.AppendNil(o) │ │ │ │ } else { │ │ │ │ - o = msgp.AppendString(o, filetostr(z.Relevent[zgmo])) │ │ │ │ + o = msgp.AppendString(o, filetostr(z.Relevent[zrbe])) │ │ │ │ } │ │ │ │ } │ │ │ │ // string "name" │ │ │ │ o = append(o, 0xa4, 0x6e, 0x61, 0x6d, 0x65) │ │ │ │ o = msgp.AppendString(o, z.Name) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *FileHandle) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zrjx uint32 │ │ │ │ - zrjx, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zbal uint32 │ │ │ │ + zbal, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zrjx > 0 { │ │ │ │ - zrjx-- │ │ │ │ + for zbal > 0 { │ │ │ │ + zbal-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "files": │ │ │ │ - var zawn uint32 │ │ │ │ - zawn, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zjqz uint32 │ │ │ │ + zjqz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Relevent) >= int(zawn) { │ │ │ │ - z.Relevent = (z.Relevent)[:zawn] │ │ │ │ + if cap(z.Relevent) >= int(zjqz) { │ │ │ │ + z.Relevent = (z.Relevent)[:zjqz] │ │ │ │ } else { │ │ │ │ - z.Relevent = make(Files, zawn) │ │ │ │ + z.Relevent = make(Files, zjqz) │ │ │ │ } │ │ │ │ - for zgmo := range z.Relevent { │ │ │ │ + for zrbe := range z.Relevent { │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ bts, err = msgp.ReadNilBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - z.Relevent[zgmo] = nil │ │ │ │ + z.Relevent[zrbe] = nil │ │ │ │ } else { │ │ │ │ { │ │ │ │ - var zwel string │ │ │ │ - zwel, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ - z.Relevent[zgmo] = filefromstr(zwel) │ │ │ │ + var zkct string │ │ │ │ + zkct, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + z.Relevent[zrbe] = filefromstr(zkct) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "name": │ │ │ │ @@ -1222,49 +1361,49 @@ │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message │ │ │ │ func (z *FileHandle) Msgsize() (s int) { │ │ │ │ s = 1 + 6 + msgp.ArrayHeaderSize │ │ │ │ - for zgmo := range z.Relevent { │ │ │ │ - if z.Relevent[zgmo] == nil { │ │ │ │ + for zrbe := range z.Relevent { │ │ │ │ + if z.Relevent[zrbe] == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ - s += msgp.StringPrefixSize + len(filetostr(z.Relevent[zgmo])) │ │ │ │ + s += msgp.StringPrefixSize + len(filetostr(z.Relevent[zrbe])) │ │ │ │ } │ │ │ │ } │ │ │ │ s += 5 + msgp.StringPrefixSize + len(z.Name) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Files) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ - var zzdc uint32 │ │ │ │ - zzdc, err = dc.ReadArrayHeader() │ │ │ │ + var zana uint32 │ │ │ │ + zana, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap((*z)) >= int(zzdc) { │ │ │ │ - (*z) = (*z)[:zzdc] │ │ │ │ + if cap((*z)) >= int(zana) { │ │ │ │ + (*z) = (*z)[:zana] │ │ │ │ } else { │ │ │ │ - (*z) = make(Files, zzdc) │ │ │ │ + (*z) = make(Files, zana) │ │ │ │ } │ │ │ │ - for zmfd := range *z { │ │ │ │ + for ztco := range *z { │ │ │ │ if dc.IsNil() { │ │ │ │ err = dc.ReadNil() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - (*z)[zmfd] = nil │ │ │ │ + (*z)[ztco] = nil │ │ │ │ } else { │ │ │ │ { │ │ │ │ - var zelx string │ │ │ │ - zelx, err = dc.ReadString() │ │ │ │ - (*z)[zmfd] = filefromstr(zelx) │ │ │ │ + var ztyy string │ │ │ │ + ztyy, err = dc.ReadString() │ │ │ │ + (*z)[ztco] = filefromstr(ztyy) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ @@ -1272,102 +1411,102 @@ │ │ │ │ │ │ │ │ // EncodeMsg implements msgp.Encodable │ │ │ │ func (z Files) EncodeMsg(en *msgp.Writer) (err error) { │ │ │ │ err = en.WriteArrayHeader(uint32(len(z))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zbal := range z { │ │ │ │ - if z[zbal] == nil { │ │ │ │ + for zinl := range z { │ │ │ │ + if z[zinl] == nil { │ │ │ │ err = en.WriteNil() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } else { │ │ │ │ - err = en.WriteString(filetostr(z[zbal])) │ │ │ │ + err = en.WriteString(filetostr(z[zinl])) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // MarshalMsg implements msgp.Marshaler │ │ │ │ func (z Files) MarshalMsg(b []byte) (o []byte, err error) { │ │ │ │ o = msgp.Require(b, z.Msgsize()) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z))) │ │ │ │ - for zbal := range z { │ │ │ │ - if z[zbal] == nil { │ │ │ │ + for zinl := range z { │ │ │ │ + if z[zinl] == nil { │ │ │ │ o = msgp.AppendNil(o) │ │ │ │ } else { │ │ │ │ - o = msgp.AppendString(o, filetostr(z[zbal])) │ │ │ │ + o = msgp.AppendString(o, filetostr(z[zinl])) │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Files) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ - var zkct uint32 │ │ │ │ - zkct, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zljy uint32 │ │ │ │ + zljy, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap((*z)) >= int(zkct) { │ │ │ │ - (*z) = (*z)[:zkct] │ │ │ │ + if cap((*z)) >= int(zljy) { │ │ │ │ + (*z) = (*z)[:zljy] │ │ │ │ } else { │ │ │ │ - (*z) = make(Files, zkct) │ │ │ │ + (*z) = make(Files, zljy) │ │ │ │ } │ │ │ │ - for zjqz := range *z { │ │ │ │ + for zare := range *z { │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ bts, err = msgp.ReadNilBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - (*z)[zjqz] = nil │ │ │ │ + (*z)[zare] = nil │ │ │ │ } else { │ │ │ │ { │ │ │ │ - var ztmt string │ │ │ │ - ztmt, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ - (*z)[zjqz] = filefromstr(ztmt) │ │ │ │ + var zixj string │ │ │ │ + zixj, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + (*z)[zare] = filefromstr(zixj) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message │ │ │ │ func (z Files) Msgsize() (s int) { │ │ │ │ s = msgp.ArrayHeaderSize │ │ │ │ - for ztco := range z { │ │ │ │ - if z[ztco] == nil { │ │ │ │ + for zrsc := range z { │ │ │ │ + if z[zrsc] == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ - s += msgp.StringPrefixSize + len(filetostr(z[ztco])) │ │ │ │ + s += msgp.StringPrefixSize + len(filetostr(z[zrsc])) │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Fixed) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zana uint32 │ │ │ │ - zana, err = dc.ReadMapHeader() │ │ │ │ + var zctn uint32 │ │ │ │ + zctn, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zana > 0 { │ │ │ │ - zana-- │ │ │ │ + for zctn > 0 { │ │ │ │ + zctn-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ z.A, err = dc.ReadFloat64() │ │ │ │ @@ -1426,21 +1565,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Fixed) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var ztyy uint32 │ │ │ │ - ztyy, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zswy uint32 │ │ │ │ + zswy, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for ztyy > 0 { │ │ │ │ - ztyy-- │ │ │ │ + for zswy > 0 { │ │ │ │ + zswy-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ z.A, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ @@ -1471,173 +1610,173 @@ │ │ │ │ │ │ │ │ // EncodeMsg implements msgp.Encodable │ │ │ │ func (z *Insane) EncodeMsg(en *msgp.Writer) (err error) { │ │ │ │ err = en.WriteArrayHeader(3) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zinl := range z { │ │ │ │ - err = en.WriteMapHeader(uint32(len(z[zinl]))) │ │ │ │ + for znsg := range z { │ │ │ │ + err = en.WriteMapHeader(uint32(len(z[znsg]))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zare, zljy := range z[zinl] { │ │ │ │ - err = en.WriteString(zare) │ │ │ │ + for zrus, zsvm := range z[znsg] { │ │ │ │ + err = en.WriteString(zrus) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ // map header, size 2 │ │ │ │ // write "A" │ │ │ │ err = en.Append(0x82, 0xa1, 0x41) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ - err = en.WriteInt(int(zljy.A)) │ │ │ │ + err = en.WriteInt(int(zsvm.A)) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ // write "B" │ │ │ │ err = en.Append(0xa1, 0x42) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ - err = en.WriteInt(int(zljy.B)) │ │ │ │ + err = en.WriteInt(int(zsvm.B)) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // MarshalMsg implements msgp.Marshaler │ │ │ │ func (z *Insane) MarshalMsg(b []byte) (o []byte, err error) { │ │ │ │ o = msgp.Require(b, z.Msgsize()) │ │ │ │ o = msgp.AppendArrayHeader(o, 3) │ │ │ │ - for zinl := range z { │ │ │ │ - o = msgp.AppendMapHeader(o, uint32(len(z[zinl]))) │ │ │ │ - for zare, zljy := range z[zinl] { │ │ │ │ - o = msgp.AppendString(o, zare) │ │ │ │ + for znsg := range z { │ │ │ │ + o = msgp.AppendMapHeader(o, uint32(len(z[znsg]))) │ │ │ │ + for zrus, zsvm := range z[znsg] { │ │ │ │ + o = msgp.AppendString(o, zrus) │ │ │ │ // map header, size 2 │ │ │ │ // string "A" │ │ │ │ o = append(o, 0x82, 0xa1, 0x41) │ │ │ │ - o = msgp.AppendInt(o, int(zljy.A)) │ │ │ │ + o = msgp.AppendInt(o, int(zsvm.A)) │ │ │ │ // string "B" │ │ │ │ o = append(o, 0xa1, 0x42) │ │ │ │ - o = msgp.AppendInt(o, int(zljy.B)) │ │ │ │ + o = msgp.AppendInt(o, int(zsvm.B)) │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Insane) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ - var zixj uint32 │ │ │ │ - zixj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zaoz uint32 │ │ │ │ + zaoz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zixj != 3 { │ │ │ │ - err = msgp.ArrayError{Wanted: 3, Got: zixj} │ │ │ │ + if zaoz != 3 { │ │ │ │ + err = msgp.ArrayError{Wanted: 3, Got: zaoz} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zinl := range z { │ │ │ │ - var zrsc uint32 │ │ │ │ - zrsc, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + for znsg := range z { │ │ │ │ + var zfzb uint32 │ │ │ │ + zfzb, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z[zinl] == nil && zrsc > 0 { │ │ │ │ - z[zinl] = make(map[string]struct { │ │ │ │ + if z[znsg] == nil && zfzb > 0 { │ │ │ │ + z[znsg] = make(map[string]struct { │ │ │ │ A CustomInt │ │ │ │ B CustomInt │ │ │ │ - }, zrsc) │ │ │ │ - } else if len(z[zinl]) > 0 { │ │ │ │ - for key, _ := range z[zinl] { │ │ │ │ - delete(z[zinl], key) │ │ │ │ + }, zfzb) │ │ │ │ + } else if len(z[znsg]) > 0 { │ │ │ │ + for key, _ := range z[znsg] { │ │ │ │ + delete(z[znsg], key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zrsc > 0 { │ │ │ │ - var zare string │ │ │ │ - var zljy struct { │ │ │ │ + for zfzb > 0 { │ │ │ │ + var zrus string │ │ │ │ + var zsvm struct { │ │ │ │ A CustomInt │ │ │ │ B CustomInt │ │ │ │ } │ │ │ │ - zrsc-- │ │ │ │ - zare, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + zfzb-- │ │ │ │ + zrus, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zctn uint32 │ │ │ │ - zctn, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zsbo uint32 │ │ │ │ + zsbo, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zctn > 0 { │ │ │ │ - zctn-- │ │ │ │ + for zsbo > 0 { │ │ │ │ + zsbo-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ { │ │ │ │ - var zswy int │ │ │ │ - zswy, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ - zljy.A = CustomInt(zswy) │ │ │ │ + var zjif int │ │ │ │ + zjif, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ + zsvm.A = CustomInt(zjif) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "B": │ │ │ │ { │ │ │ │ - var znsg int │ │ │ │ - znsg, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ - zljy.B = CustomInt(znsg) │ │ │ │ + var zqgz int │ │ │ │ + zqgz, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ + zsvm.B = CustomInt(zqgz) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ default: │ │ │ │ bts, err = msgp.Skip(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ - z[zinl][zare] = zljy │ │ │ │ + z[znsg][zrus] = zsvm │ │ │ │ } │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message │ │ │ │ func (z *Insane) Msgsize() (s int) { │ │ │ │ s = msgp.ArrayHeaderSize │ │ │ │ - for zinl := range z { │ │ │ │ + for znsg := range z { │ │ │ │ s += msgp.MapHeaderSize │ │ │ │ - if z[zinl] != nil { │ │ │ │ - for zare, zljy := range z[zinl] { │ │ │ │ - _ = zljy │ │ │ │ - s += msgp.StringPrefixSize + len(zare) + 1 + 2 + msgp.IntSize + 2 + msgp.IntSize │ │ │ │ + if z[znsg] != nil { │ │ │ │ + for zrus, zsvm := range z[znsg] { │ │ │ │ + _ = zsvm │ │ │ │ + s += msgp.StringPrefixSize + len(zrus) + 1 + 2 + msgp.IntSize + 2 + msgp.IntSize │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *IntA) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zrus int │ │ │ │ - zrus, err = dc.ReadInt() │ │ │ │ - (*z) = IntA(zrus) │ │ │ │ + var zsnw int │ │ │ │ + zsnw, err = dc.ReadInt() │ │ │ │ + (*z) = IntA(zsnw) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -1656,17 +1795,17 @@ │ │ │ │ o = msgp.AppendInt(o, int(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *IntA) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zsvm int │ │ │ │ - zsvm, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ - (*z) = IntA(zsvm) │ │ │ │ + var ztls int │ │ │ │ + ztls, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ + (*z) = IntA(ztls) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -1676,17 +1815,17 @@ │ │ │ │ s = msgp.IntSize │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *IntB) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zaoz int │ │ │ │ - zaoz, err = dc.ReadInt() │ │ │ │ - (*z) = IntB(zaoz) │ │ │ │ + var zmvo int │ │ │ │ + zmvo, err = dc.ReadInt() │ │ │ │ + (*z) = IntB(zmvo) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -1705,17 +1844,17 @@ │ │ │ │ o = msgp.AppendInt(o, int(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *IntB) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zfzb int │ │ │ │ - zfzb, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ - (*z) = IntB(zfzb) │ │ │ │ + var zigk int │ │ │ │ + zigk, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ + (*z) = IntB(zigk) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -1725,17 +1864,17 @@ │ │ │ │ s = msgp.IntSize │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *IntC) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zsbo int │ │ │ │ - zsbo, err = dc.ReadInt() │ │ │ │ - (*z) = IntC(zsbo) │ │ │ │ + var zopb int │ │ │ │ + zopb, err = dc.ReadInt() │ │ │ │ + (*z) = IntC(zopb) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -1754,17 +1893,17 @@ │ │ │ │ o = msgp.AppendInt(o, int(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *IntC) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zjif int │ │ │ │ - zjif, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ - (*z) = IntC(zjif) │ │ │ │ + var zuop int │ │ │ │ + zuop, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ + (*z) = IntC(zuop) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -1774,17 +1913,17 @@ │ │ │ │ s = msgp.IntSize │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *MyEnum) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zqgz string │ │ │ │ - zqgz, err = dc.ReadString() │ │ │ │ - (*z) = myenumStr(zqgz) │ │ │ │ + var zedl string │ │ │ │ + zedl, err = dc.ReadString() │ │ │ │ + (*z) = myenumStr(zedl) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -1803,17 +1942,17 @@ │ │ │ │ o = msgp.AppendString(o, (MyEnum).String(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *MyEnum) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zsnw string │ │ │ │ - zsnw, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ - (*z) = myenumStr(zsnw) │ │ │ │ + var zupd string │ │ │ │ + zupd, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + (*z) = myenumStr(zupd) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -1822,106 +1961,106 @@ │ │ │ │ func (z MyEnum) Msgsize() (s int) { │ │ │ │ s = msgp.StringPrefixSize + len((MyEnum).String(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Object) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ - var zupd uint32 │ │ │ │ - zupd, err = dc.ReadArrayHeader() │ │ │ │ + var zlsx uint32 │ │ │ │ + zlsx, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zupd != 4 { │ │ │ │ - err = msgp.ArrayError{Wanted: 4, Got: zupd} │ │ │ │ + if zlsx != 4 { │ │ │ │ + err = msgp.ArrayError{Wanted: 4, Got: zlsx} │ │ │ │ return │ │ │ │ } │ │ │ │ z.ObjectNo, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - var zome uint32 │ │ │ │ - zome, err = dc.ReadArrayHeader() │ │ │ │ + var zbgy uint32 │ │ │ │ + zbgy, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice1) >= int(zome) { │ │ │ │ - z.Slice1 = (z.Slice1)[:zome] │ │ │ │ + if cap(z.Slice1) >= int(zbgy) { │ │ │ │ + z.Slice1 = (z.Slice1)[:zbgy] │ │ │ │ } else { │ │ │ │ - z.Slice1 = make([]string, zome) │ │ │ │ + z.Slice1 = make([]string, zbgy) │ │ │ │ } │ │ │ │ - for ztls := range z.Slice1 { │ │ │ │ - z.Slice1[ztls], err = dc.ReadString() │ │ │ │ + for zome := range z.Slice1 { │ │ │ │ + z.Slice1[zome], err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ - var zrvj uint32 │ │ │ │ - zrvj, err = dc.ReadArrayHeader() │ │ │ │ + var zrao uint32 │ │ │ │ + zrao, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice2) >= int(zrvj) { │ │ │ │ - z.Slice2 = (z.Slice2)[:zrvj] │ │ │ │ + if cap(z.Slice2) >= int(zrao) { │ │ │ │ + z.Slice2 = (z.Slice2)[:zrao] │ │ │ │ } else { │ │ │ │ - z.Slice2 = make([]string, zrvj) │ │ │ │ + z.Slice2 = make([]string, zrao) │ │ │ │ } │ │ │ │ - for zmvo := range z.Slice2 { │ │ │ │ - z.Slice2[zmvo], err = dc.ReadString() │ │ │ │ + for zrvj := range z.Slice2 { │ │ │ │ + z.Slice2[zrvj], err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ - var zarz uint32 │ │ │ │ - zarz, err = dc.ReadMapHeader() │ │ │ │ + var zmbt uint32 │ │ │ │ + zmbt, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z.MapMap == nil && zarz > 0 { │ │ │ │ - z.MapMap = make(map[string]map[string]string, zarz) │ │ │ │ + if z.MapMap == nil && zmbt > 0 { │ │ │ │ + z.MapMap = make(map[string]map[string]string, zmbt) │ │ │ │ } else if len(z.MapMap) > 0 { │ │ │ │ for key, _ := range z.MapMap { │ │ │ │ delete(z.MapMap, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zarz > 0 { │ │ │ │ - zarz-- │ │ │ │ - var zigk string │ │ │ │ - var zopb map[string]string │ │ │ │ - zigk, err = dc.ReadString() │ │ │ │ + for zmbt > 0 { │ │ │ │ + zmbt-- │ │ │ │ + var zarz string │ │ │ │ + var zknt map[string]string │ │ │ │ + zarz, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - var zknt uint32 │ │ │ │ - zknt, err = dc.ReadMapHeader() │ │ │ │ + var zvls uint32 │ │ │ │ + zvls, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zopb == nil && zknt > 0 { │ │ │ │ - zopb = make(map[string]string, zknt) │ │ │ │ - } else if len(zopb) > 0 { │ │ │ │ - for key, _ := range zopb { │ │ │ │ - delete(zopb, key) │ │ │ │ + if zknt == nil && zvls > 0 { │ │ │ │ + zknt = make(map[string]string, zvls) │ │ │ │ + } else if len(zknt) > 0 { │ │ │ │ + for key, _ := range zknt { │ │ │ │ + delete(zknt, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zknt > 0 { │ │ │ │ - zknt-- │ │ │ │ - var zuop string │ │ │ │ - var zedl string │ │ │ │ - zuop, err = dc.ReadString() │ │ │ │ + for zvls > 0 { │ │ │ │ + zvls-- │ │ │ │ + var zxye string │ │ │ │ + var zucw string │ │ │ │ + zxye, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - zedl, err = dc.ReadString() │ │ │ │ + zucw, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - zopb[zuop] = zedl │ │ │ │ + zknt[zxye] = zucw │ │ │ │ } │ │ │ │ - z.MapMap[zigk] = zopb │ │ │ │ + z.MapMap[zarz] = zknt │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // EncodeMsg implements msgp.Encodable │ │ │ │ func (z *Object) EncodeMsg(en *msgp.Writer) (err error) { │ │ │ │ // array header, size 4 │ │ │ │ @@ -1933,49 +2072,49 @@ │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Slice1))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for ztls := range z.Slice1 { │ │ │ │ - err = en.WriteString(z.Slice1[ztls]) │ │ │ │ + for zome := range z.Slice1 { │ │ │ │ + err = en.WriteString(z.Slice1[zome]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Slice2))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zmvo := range z.Slice2 { │ │ │ │ - err = en.WriteString(z.Slice2[zmvo]) │ │ │ │ + for zrvj := range z.Slice2 { │ │ │ │ + err = en.WriteString(z.Slice2[zrvj]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ err = en.WriteMapHeader(uint32(len(z.MapMap))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zigk, zopb := range z.MapMap { │ │ │ │ - err = en.WriteString(zigk) │ │ │ │ + for zarz, zknt := range z.MapMap { │ │ │ │ + err = en.WriteString(zarz) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - err = en.WriteMapHeader(uint32(len(zopb))) │ │ │ │ + err = en.WriteMapHeader(uint32(len(zknt))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zuop, zedl := range zopb { │ │ │ │ - err = en.WriteString(zuop) │ │ │ │ + for zxye, zucw := range zknt { │ │ │ │ + err = en.WriteString(zxye) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - err = en.WriteString(zedl) │ │ │ │ + err = en.WriteString(zucw) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -1983,164 +2122,164 @@ │ │ │ │ // MarshalMsg implements msgp.Marshaler │ │ │ │ func (z *Object) MarshalMsg(b []byte) (o []byte, err error) { │ │ │ │ o = msgp.Require(b, z.Msgsize()) │ │ │ │ // array header, size 4 │ │ │ │ o = append(o, 0x94) │ │ │ │ o = msgp.AppendString(o, z.ObjectNo) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Slice1))) │ │ │ │ - for ztls := range z.Slice1 { │ │ │ │ - o = msgp.AppendString(o, z.Slice1[ztls]) │ │ │ │ + for zome := range z.Slice1 { │ │ │ │ + o = msgp.AppendString(o, z.Slice1[zome]) │ │ │ │ } │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Slice2))) │ │ │ │ - for zmvo := range z.Slice2 { │ │ │ │ - o = msgp.AppendString(o, z.Slice2[zmvo]) │ │ │ │ + for zrvj := range z.Slice2 { │ │ │ │ + o = msgp.AppendString(o, z.Slice2[zrvj]) │ │ │ │ } │ │ │ │ o = msgp.AppendMapHeader(o, uint32(len(z.MapMap))) │ │ │ │ - for zigk, zopb := range z.MapMap { │ │ │ │ - o = msgp.AppendString(o, zigk) │ │ │ │ - o = msgp.AppendMapHeader(o, uint32(len(zopb))) │ │ │ │ - for zuop, zedl := range zopb { │ │ │ │ - o = msgp.AppendString(o, zuop) │ │ │ │ - o = msgp.AppendString(o, zedl) │ │ │ │ + for zarz, zknt := range z.MapMap { │ │ │ │ + o = msgp.AppendString(o, zarz) │ │ │ │ + o = msgp.AppendMapHeader(o, uint32(len(zknt))) │ │ │ │ + for zxye, zucw := range zknt { │ │ │ │ + o = msgp.AppendString(o, zxye) │ │ │ │ + o = msgp.AppendString(o, zucw) │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Object) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ - var zxye uint32 │ │ │ │ - zxye, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zjfj uint32 │ │ │ │ + zjfj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zxye != 4 { │ │ │ │ - err = msgp.ArrayError{Wanted: 4, Got: zxye} │ │ │ │ + if zjfj != 4 { │ │ │ │ + err = msgp.ArrayError{Wanted: 4, Got: zjfj} │ │ │ │ return │ │ │ │ } │ │ │ │ z.ObjectNo, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - var zucw uint32 │ │ │ │ - zucw, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zzak uint32 │ │ │ │ + zzak, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice1) >= int(zucw) { │ │ │ │ - z.Slice1 = (z.Slice1)[:zucw] │ │ │ │ + if cap(z.Slice1) >= int(zzak) { │ │ │ │ + z.Slice1 = (z.Slice1)[:zzak] │ │ │ │ } else { │ │ │ │ - z.Slice1 = make([]string, zucw) │ │ │ │ + z.Slice1 = make([]string, zzak) │ │ │ │ } │ │ │ │ - for ztls := range z.Slice1 { │ │ │ │ - z.Slice1[ztls], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zome := range z.Slice1 { │ │ │ │ + z.Slice1[zome], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ - var zlsx uint32 │ │ │ │ - zlsx, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zbtz uint32 │ │ │ │ + zbtz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice2) >= int(zlsx) { │ │ │ │ - z.Slice2 = (z.Slice2)[:zlsx] │ │ │ │ + if cap(z.Slice2) >= int(zbtz) { │ │ │ │ + z.Slice2 = (z.Slice2)[:zbtz] │ │ │ │ } else { │ │ │ │ - z.Slice2 = make([]string, zlsx) │ │ │ │ + z.Slice2 = make([]string, zbtz) │ │ │ │ } │ │ │ │ - for zmvo := range z.Slice2 { │ │ │ │ - z.Slice2[zmvo], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zrvj := range z.Slice2 { │ │ │ │ + z.Slice2[zrvj], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ - var zbgy uint32 │ │ │ │ - zbgy, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zsym uint32 │ │ │ │ + zsym, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z.MapMap == nil && zbgy > 0 { │ │ │ │ - z.MapMap = make(map[string]map[string]string, zbgy) │ │ │ │ + if z.MapMap == nil && zsym > 0 { │ │ │ │ + z.MapMap = make(map[string]map[string]string, zsym) │ │ │ │ } else if len(z.MapMap) > 0 { │ │ │ │ for key, _ := range z.MapMap { │ │ │ │ delete(z.MapMap, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zbgy > 0 { │ │ │ │ - var zigk string │ │ │ │ - var zopb map[string]string │ │ │ │ - zbgy-- │ │ │ │ - zigk, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zsym > 0 { │ │ │ │ + var zarz string │ │ │ │ + var zknt map[string]string │ │ │ │ + zsym-- │ │ │ │ + zarz, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - var zrao uint32 │ │ │ │ - zrao, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zgeu uint32 │ │ │ │ + zgeu, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zopb == nil && zrao > 0 { │ │ │ │ - zopb = make(map[string]string, zrao) │ │ │ │ - } else if len(zopb) > 0 { │ │ │ │ - for key, _ := range zopb { │ │ │ │ - delete(zopb, key) │ │ │ │ + if zknt == nil && zgeu > 0 { │ │ │ │ + zknt = make(map[string]string, zgeu) │ │ │ │ + } else if len(zknt) > 0 { │ │ │ │ + for key, _ := range zknt { │ │ │ │ + delete(zknt, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zrao > 0 { │ │ │ │ - var zuop string │ │ │ │ - var zedl string │ │ │ │ - zrao-- │ │ │ │ - zuop, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zgeu > 0 { │ │ │ │ + var zxye string │ │ │ │ + var zucw string │ │ │ │ + zgeu-- │ │ │ │ + zxye, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - zedl, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + zucw, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - zopb[zuop] = zedl │ │ │ │ + zknt[zxye] = zucw │ │ │ │ } │ │ │ │ - z.MapMap[zigk] = zopb │ │ │ │ + z.MapMap[zarz] = zknt │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message │ │ │ │ func (z *Object) Msgsize() (s int) { │ │ │ │ s = 1 + msgp.StringPrefixSize + len(z.ObjectNo) + msgp.ArrayHeaderSize │ │ │ │ - for ztls := range z.Slice1 { │ │ │ │ - s += msgp.StringPrefixSize + len(z.Slice1[ztls]) │ │ │ │ + for zome := range z.Slice1 { │ │ │ │ + s += msgp.StringPrefixSize + len(z.Slice1[zome]) │ │ │ │ } │ │ │ │ s += msgp.ArrayHeaderSize │ │ │ │ - for zmvo := range z.Slice2 { │ │ │ │ - s += msgp.StringPrefixSize + len(z.Slice2[zmvo]) │ │ │ │ + for zrvj := range z.Slice2 { │ │ │ │ + s += msgp.StringPrefixSize + len(z.Slice2[zrvj]) │ │ │ │ } │ │ │ │ s += msgp.MapHeaderSize │ │ │ │ if z.MapMap != nil { │ │ │ │ - for zigk, zopb := range z.MapMap { │ │ │ │ - _ = zopb │ │ │ │ - s += msgp.StringPrefixSize + len(zigk) + msgp.MapHeaderSize │ │ │ │ - if zopb != nil { │ │ │ │ - for zuop, zedl := range zopb { │ │ │ │ - _ = zedl │ │ │ │ - s += msgp.StringPrefixSize + len(zuop) + msgp.StringPrefixSize + len(zedl) │ │ │ │ + for zarz, zknt := range z.MapMap { │ │ │ │ + _ = zknt │ │ │ │ + s += msgp.StringPrefixSize + len(zarz) + msgp.MapHeaderSize │ │ │ │ + if zknt != nil { │ │ │ │ + for zxye, zucw := range zknt { │ │ │ │ + _ = zucw │ │ │ │ + s += msgp.StringPrefixSize + len(zxye) + msgp.StringPrefixSize + len(zucw) │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *SpecialID) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ { │ │ │ │ - var zmbt []byte │ │ │ │ - zmbt, err = dc.ReadBytes([]byte((*z))) │ │ │ │ - (*z) = fromBytes(zmbt) │ │ │ │ + var zdtr []byte │ │ │ │ + zdtr, err = dc.ReadBytes([]byte((*z))) │ │ │ │ + (*z) = fromBytes(zdtr) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -2159,17 +2298,17 @@ │ │ │ │ o = msgp.AppendBytes(o, toBytes(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *SpecialID) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ { │ │ │ │ - var zvls []byte │ │ │ │ - zvls, bts, err = msgp.ReadBytesBytes(bts, toBytes((*z))) │ │ │ │ - (*z) = fromBytes(zvls) │ │ │ │ + var zzqm []byte │ │ │ │ + zzqm, bts, err = msgp.ReadBytesBytes(bts, toBytes((*z))) │ │ │ │ + (*z) = fromBytes(zzqm) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -2178,21 +2317,21 @@ │ │ │ │ func (z SpecialID) Msgsize() (s int) { │ │ │ │ s = msgp.BytesPrefixSize + len(toBytes(z)) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *TestBench) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ - var zjfj uint32 │ │ │ │ - zjfj, err = dc.ReadArrayHeader() │ │ │ │ + var zdqi uint32 │ │ │ │ + zdqi, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zjfj != 6 { │ │ │ │ - err = msgp.ArrayError{Wanted: 6, Got: zjfj} │ │ │ │ + if zdqi != 6 { │ │ │ │ + err = msgp.ArrayError{Wanted: 6, Got: zdqi} │ │ │ │ return │ │ │ │ } │ │ │ │ z.Name, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ z.BirthDay, err = dc.ReadTime() │ │ │ │ @@ -2264,21 +2403,21 @@ │ │ │ │ o = msgp.AppendBool(o, z.Spouse) │ │ │ │ o = msgp.AppendFloat64(o, z.Money) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *TestBench) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ - var zzak uint32 │ │ │ │ - zzak, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zyco uint32 │ │ │ │ + zyco, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zzak != 6 { │ │ │ │ - err = msgp.ArrayError{Wanted: 6, Got: zzak} │ │ │ │ + if zyco != 6 { │ │ │ │ + err = msgp.ArrayError{Wanted: 6, Got: zyco} │ │ │ │ return │ │ │ │ } │ │ │ │ z.Name, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ z.BirthDay, bts, err = msgp.ReadTimeBytes(bts) │ │ │ │ @@ -2309,21 +2448,21 @@ │ │ │ │ func (z *TestBench) Msgsize() (s int) { │ │ │ │ s = 1 + msgp.StringPrefixSize + len(z.Name) + msgp.TimeSize + msgp.StringPrefixSize + len(z.Phone) + msgp.IntSize + msgp.BoolSize + msgp.Float64Size │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *TestFast) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ - var zbtz uint32 │ │ │ │ - zbtz, err = dc.ReadArrayHeader() │ │ │ │ + var zhgh uint32 │ │ │ │ + zhgh, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zbtz != 4 { │ │ │ │ - err = msgp.ArrayError{Wanted: 4, Got: zbtz} │ │ │ │ + if zhgh != 4 { │ │ │ │ + err = msgp.ArrayError{Wanted: 4, Got: zhgh} │ │ │ │ return │ │ │ │ } │ │ │ │ z.Lat, err = dc.ReadFloat64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ z.Long, err = dc.ReadFloat64() │ │ │ │ @@ -2377,21 +2516,21 @@ │ │ │ │ o = msgp.AppendFloat64(o, z.Alt) │ │ │ │ o = msgp.AppendBytes(o, z.Data) │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *TestFast) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ - var zsym uint32 │ │ │ │ - zsym, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zovg uint32 │ │ │ │ + zovg, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zsym != 4 { │ │ │ │ - err = msgp.ArrayError{Wanted: 4, Got: zsym} │ │ │ │ + if zovg != 4 { │ │ │ │ + err = msgp.ArrayError{Wanted: 4, Got: zovg} │ │ │ │ return │ │ │ │ } │ │ │ │ z.Lat, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ z.Long, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ @@ -2416,44 +2555,44 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *TestHidden) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zdtr uint32 │ │ │ │ - zdtr, err = dc.ReadMapHeader() │ │ │ │ + var zcjp uint32 │ │ │ │ + zcjp, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zdtr > 0 { │ │ │ │ - zdtr-- │ │ │ │ + for zcjp > 0 { │ │ │ │ + zcjp-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ z.A, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "B": │ │ │ │ - var zzqm uint32 │ │ │ │ - zzqm, err = dc.ReadArrayHeader() │ │ │ │ + var zjhy uint32 │ │ │ │ + zjhy, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.B) >= int(zzqm) { │ │ │ │ - z.B = (z.B)[:zzqm] │ │ │ │ + if cap(z.B) >= int(zjhy) { │ │ │ │ + z.B = (z.B)[:zjhy] │ │ │ │ } else { │ │ │ │ - z.B = make([]float64, zzqm) │ │ │ │ + z.B = make([]float64, zjhy) │ │ │ │ } │ │ │ │ - for zgeu := range z.B { │ │ │ │ - z.B[zgeu], err = dc.ReadFloat64() │ │ │ │ + for zsey := range z.B { │ │ │ │ + z.B[zsey], err = dc.ReadFloat64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ default: │ │ │ │ err = dc.Skip() │ │ │ │ if err != nil { │ │ │ │ @@ -2481,16 +2620,16 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.B))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zgeu := range z.B { │ │ │ │ - err = en.WriteFloat64(z.B[zgeu]) │ │ │ │ + for zsey := range z.B { │ │ │ │ + err = en.WriteFloat64(z.B[zsey]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -2500,54 +2639,54 @@ │ │ │ │ // map header, size 2 │ │ │ │ // string "A" │ │ │ │ o = append(o, 0x82, 0xa1, 0x41) │ │ │ │ o = msgp.AppendString(o, z.A) │ │ │ │ // string "B" │ │ │ │ o = append(o, 0xa1, 0x42) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.B))) │ │ │ │ - for zgeu := range z.B { │ │ │ │ - o = msgp.AppendFloat64(o, z.B[zgeu]) │ │ │ │ + for zsey := range z.B { │ │ │ │ + o = msgp.AppendFloat64(o, z.B[zsey]) │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *TestHidden) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zdqi uint32 │ │ │ │ - zdqi, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var znuf uint32 │ │ │ │ + znuf, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zdqi > 0 { │ │ │ │ - zdqi-- │ │ │ │ + for znuf > 0 { │ │ │ │ + znuf-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ z.A, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "B": │ │ │ │ - var zyco uint32 │ │ │ │ - zyco, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var znjj uint32 │ │ │ │ + znjj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.B) >= int(zyco) { │ │ │ │ - z.B = (z.B)[:zyco] │ │ │ │ + if cap(z.B) >= int(znjj) { │ │ │ │ + z.B = (z.B)[:znjj] │ │ │ │ } else { │ │ │ │ - z.B = make([]float64, zyco) │ │ │ │ + z.B = make([]float64, znjj) │ │ │ │ } │ │ │ │ - for zgeu := range z.B { │ │ │ │ - z.B[zgeu], bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ + for zsey := range z.B { │ │ │ │ + z.B[zsey], bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ default: │ │ │ │ bts, err = msgp.Skip(bts) │ │ │ │ if err != nil { │ │ │ │ @@ -2565,40 +2704,40 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *TestObj) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zhgh uint32 │ │ │ │ - zhgh, err = dc.ReadMapHeader() │ │ │ │ + var zhhj uint32 │ │ │ │ + zhhj, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zhgh > 0 { │ │ │ │ - zhgh-- │ │ │ │ + for zhhj > 0 { │ │ │ │ + zhhj-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "ID1": │ │ │ │ { │ │ │ │ - var zovg []byte │ │ │ │ - zovg, err = dc.ReadBytes([]byte(z.ID1)) │ │ │ │ - z.ID1 = fromBytes(zovg) │ │ │ │ + var zuvr []byte │ │ │ │ + zuvr, err = dc.ReadBytes([]byte(z.ID1)) │ │ │ │ + z.ID1 = fromBytes(zuvr) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "ID2": │ │ │ │ { │ │ │ │ - var zsey []byte │ │ │ │ - zsey, err = dc.ReadBytes([]byte(z.ID2)) │ │ │ │ - z.ID2 = fromBytes(zsey) │ │ │ │ + var zusq []byte │ │ │ │ + zusq, err = dc.ReadBytes([]byte(z.ID2)) │ │ │ │ + z.ID2 = fromBytes(zusq) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ default: │ │ │ │ err = dc.Skip() │ │ │ │ if err != nil { │ │ │ │ @@ -2646,40 +2785,40 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *TestObj) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zcjp uint32 │ │ │ │ - zcjp, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zfgq uint32 │ │ │ │ + zfgq, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zcjp > 0 { │ │ │ │ - zcjp-- │ │ │ │ + for zfgq > 0 { │ │ │ │ + zfgq-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "ID1": │ │ │ │ { │ │ │ │ - var zjhy []byte │ │ │ │ - zjhy, bts, err = msgp.ReadBytesBytes(bts, toBytes(z.ID1)) │ │ │ │ - z.ID1 = fromBytes(zjhy) │ │ │ │ + var zvml []byte │ │ │ │ + zvml, bts, err = msgp.ReadBytesBytes(bts, toBytes(z.ID1)) │ │ │ │ + z.ID1 = fromBytes(zvml) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "ID2": │ │ │ │ { │ │ │ │ - var znuf []byte │ │ │ │ - znuf, bts, err = msgp.ReadBytesBytes(bts, toBytes(z.ID2)) │ │ │ │ - z.ID2 = fromBytes(znuf) │ │ │ │ + var zpyv []byte │ │ │ │ + zpyv, bts, err = msgp.ReadBytesBytes(bts, toBytes(z.ID2)) │ │ │ │ + z.ID2 = fromBytes(zpyv) │ │ │ │ } │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ default: │ │ │ │ bts, err = msgp.Skip(bts) │ │ │ │ if err != nil { │ │ │ │ @@ -2697,21 +2836,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *TestType) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zvml uint32 │ │ │ │ - zvml, err = dc.ReadMapHeader() │ │ │ │ + var zarl uint32 │ │ │ │ + zarl, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zvml > 0 { │ │ │ │ - zvml-- │ │ │ │ + for zarl > 0 { │ │ │ │ + zarl-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "float": │ │ │ │ if dc.IsNil() { │ │ │ │ @@ -2726,48 +2865,48 @@ │ │ │ │ } │ │ │ │ *z.F, err = dc.ReadFloat64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "elements": │ │ │ │ - var zpyv uint32 │ │ │ │ - zpyv, err = dc.ReadMapHeader() │ │ │ │ + var zctz uint32 │ │ │ │ + zctz, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z.Els == nil && zpyv > 0 { │ │ │ │ - z.Els = make(map[string]string, zpyv) │ │ │ │ + if z.Els == nil && zctz > 0 { │ │ │ │ + z.Els = make(map[string]string, zctz) │ │ │ │ } else if len(z.Els) > 0 { │ │ │ │ for key, _ := range z.Els { │ │ │ │ delete(z.Els, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zpyv > 0 { │ │ │ │ - zpyv-- │ │ │ │ - var znjj string │ │ │ │ - var zhhj string │ │ │ │ - znjj, err = dc.ReadString() │ │ │ │ + for zctz > 0 { │ │ │ │ + zctz-- │ │ │ │ + var zlur string │ │ │ │ + var zupi string │ │ │ │ + zlur, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - zhhj, err = dc.ReadString() │ │ │ │ + zupi, err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - z.Els[znjj] = zhhj │ │ │ │ + z.Els[zlur] = zupi │ │ │ │ } │ │ │ │ case "object": │ │ │ │ - var zlur uint32 │ │ │ │ - zlur, err = dc.ReadMapHeader() │ │ │ │ + var zljl uint32 │ │ │ │ + zljl, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zlur > 0 { │ │ │ │ - zlur-- │ │ │ │ + for zljl > 0 { │ │ │ │ + zljl-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "value_a": │ │ │ │ z.Obj.ValueA, err = dc.ReadString() │ │ │ │ @@ -2819,43 +2958,43 @@ │ │ │ │ } │ │ │ │ case "num": │ │ │ │ err = z.Num.DecodeMsg(dc) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "Slice1": │ │ │ │ - var zupi uint32 │ │ │ │ - zupi, err = dc.ReadArrayHeader() │ │ │ │ + var zziv uint32 │ │ │ │ + zziv, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice1) >= int(zupi) { │ │ │ │ - z.Slice1 = (z.Slice1)[:zupi] │ │ │ │ + if cap(z.Slice1) >= int(zziv) { │ │ │ │ + z.Slice1 = (z.Slice1)[:zziv] │ │ │ │ } else { │ │ │ │ - z.Slice1 = make([]string, zupi) │ │ │ │ + z.Slice1 = make([]string, zziv) │ │ │ │ } │ │ │ │ - for zuvr := range z.Slice1 { │ │ │ │ - z.Slice1[zuvr], err = dc.ReadString() │ │ │ │ + for zfvi := range z.Slice1 { │ │ │ │ + z.Slice1[zfvi], err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Slice2": │ │ │ │ - var zfvi uint32 │ │ │ │ - zfvi, err = dc.ReadArrayHeader() │ │ │ │ + var zabj uint32 │ │ │ │ + zabj, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice2) >= int(zfvi) { │ │ │ │ - z.Slice2 = (z.Slice2)[:zfvi] │ │ │ │ + if cap(z.Slice2) >= int(zabj) { │ │ │ │ + z.Slice2 = (z.Slice2)[:zabj] │ │ │ │ } else { │ │ │ │ - z.Slice2 = make([]string, zfvi) │ │ │ │ + z.Slice2 = make([]string, zabj) │ │ │ │ } │ │ │ │ - for zusq := range z.Slice2 { │ │ │ │ - z.Slice2[zusq], err = dc.ReadString() │ │ │ │ + for zzrg := range z.Slice2 { │ │ │ │ + z.Slice2[zzrg], err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "SlicePtr": │ │ │ │ if dc.IsNil() { │ │ │ │ err = dc.ReadNil() │ │ │ │ @@ -2863,26 +3002,26 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ z.SlicePtr = nil │ │ │ │ } else { │ │ │ │ if z.SlicePtr == nil { │ │ │ │ z.SlicePtr = new([]string) │ │ │ │ } │ │ │ │ - var zzrg uint32 │ │ │ │ - zzrg, err = dc.ReadArrayHeader() │ │ │ │ + var zmlx uint32 │ │ │ │ + zmlx, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(*z.SlicePtr) >= int(zzrg) { │ │ │ │ - *z.SlicePtr = (*z.SlicePtr)[:zzrg] │ │ │ │ + if cap(*z.SlicePtr) >= int(zmlx) { │ │ │ │ + *z.SlicePtr = (*z.SlicePtr)[:zmlx] │ │ │ │ } else { │ │ │ │ - *z.SlicePtr = make([]string, zzrg) │ │ │ │ + *z.SlicePtr = make([]string, zmlx) │ │ │ │ } │ │ │ │ - for zfgq := range *z.SlicePtr { │ │ │ │ - (*z.SlicePtr)[zfgq], err = dc.ReadString() │ │ │ │ + for zbmy := range *z.SlicePtr { │ │ │ │ + (*z.SlicePtr)[zbmy], err = dc.ReadString() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ default: │ │ │ │ err = dc.Skip() │ │ │ │ @@ -2918,20 +3057,20 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteMapHeader(uint32(len(z.Els))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for znjj, zhhj := range z.Els { │ │ │ │ - err = en.WriteString(znjj) │ │ │ │ + for zlur, zupi := range z.Els { │ │ │ │ + err = en.WriteString(zlur) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - err = en.WriteString(zhhj) │ │ │ │ + err = en.WriteString(zupi) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "object" │ │ │ │ // map header, size 2 │ │ │ │ // write "value_a" │ │ │ │ @@ -3009,31 +3148,31 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Slice1))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zuvr := range z.Slice1 { │ │ │ │ - err = en.WriteString(z.Slice1[zuvr]) │ │ │ │ + for zfvi := range z.Slice1 { │ │ │ │ + err = en.WriteString(z.Slice1[zfvi]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "Slice2" │ │ │ │ err = en.Append(0xa6, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x32) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Slice2))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zusq := range z.Slice2 { │ │ │ │ - err = en.WriteString(z.Slice2[zusq]) │ │ │ │ + for zzrg := range z.Slice2 { │ │ │ │ + err = en.WriteString(z.Slice2[zzrg]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "SlicePtr" │ │ │ │ err = en.Append(0xa8, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x50, 0x74, 0x72) │ │ │ │ if err != nil { │ │ │ │ @@ -3045,16 +3184,16 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ } else { │ │ │ │ err = en.WriteArrayHeader(uint32(len(*z.SlicePtr))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zfgq := range *z.SlicePtr { │ │ │ │ - err = en.WriteString((*z.SlicePtr)[zfgq]) │ │ │ │ + for zbmy := range *z.SlicePtr { │ │ │ │ + err = en.WriteString((*z.SlicePtr)[zbmy]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ @@ -3069,17 +3208,17 @@ │ │ │ │ o = msgp.AppendNil(o) │ │ │ │ } else { │ │ │ │ o = msgp.AppendFloat64(o, *z.F) │ │ │ │ } │ │ │ │ // string "elements" │ │ │ │ o = append(o, 0xa8, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73) │ │ │ │ o = msgp.AppendMapHeader(o, uint32(len(z.Els))) │ │ │ │ - for znjj, zhhj := range z.Els { │ │ │ │ - o = msgp.AppendString(o, znjj) │ │ │ │ - o = msgp.AppendString(o, zhhj) │ │ │ │ + for zlur, zupi := range z.Els { │ │ │ │ + o = msgp.AppendString(o, zlur) │ │ │ │ + o = msgp.AppendString(o, zupi) │ │ │ │ } │ │ │ │ // string "object" │ │ │ │ // map header, size 2 │ │ │ │ // string "value_a" │ │ │ │ o = append(o, 0xa6, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x82, 0xa7, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x61) │ │ │ │ o = msgp.AppendString(o, z.Obj.ValueA) │ │ │ │ // string "value_b" │ │ │ │ @@ -3115,47 +3254,47 @@ │ │ │ │ o, err = z.Num.MarshalMsg(o) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ // string "Slice1" │ │ │ │ o = append(o, 0xa6, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x31) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Slice1))) │ │ │ │ - for zuvr := range z.Slice1 { │ │ │ │ - o = msgp.AppendString(o, z.Slice1[zuvr]) │ │ │ │ + for zfvi := range z.Slice1 { │ │ │ │ + o = msgp.AppendString(o, z.Slice1[zfvi]) │ │ │ │ } │ │ │ │ // string "Slice2" │ │ │ │ o = append(o, 0xa6, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x32) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Slice2))) │ │ │ │ - for zusq := range z.Slice2 { │ │ │ │ - o = msgp.AppendString(o, z.Slice2[zusq]) │ │ │ │ + for zzrg := range z.Slice2 { │ │ │ │ + o = msgp.AppendString(o, z.Slice2[zzrg]) │ │ │ │ } │ │ │ │ // string "SlicePtr" │ │ │ │ o = append(o, 0xa8, 0x53, 0x6c, 0x69, 0x63, 0x65, 0x50, 0x74, 0x72) │ │ │ │ if z.SlicePtr == nil { │ │ │ │ o = msgp.AppendNil(o) │ │ │ │ } else { │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(*z.SlicePtr))) │ │ │ │ - for zfgq := range *z.SlicePtr { │ │ │ │ - o = msgp.AppendString(o, (*z.SlicePtr)[zfgq]) │ │ │ │ + for zbmy := range *z.SlicePtr { │ │ │ │ + o = msgp.AppendString(o, (*z.SlicePtr)[zbmy]) │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *TestType) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zbmy uint32 │ │ │ │ - zbmy, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zvbw uint32 │ │ │ │ + zvbw, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zbmy > 0 { │ │ │ │ - zbmy-- │ │ │ │ + for zvbw > 0 { │ │ │ │ + zvbw-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "float": │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ @@ -3170,48 +3309,48 @@ │ │ │ │ } │ │ │ │ *z.F, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "elements": │ │ │ │ - var zarl uint32 │ │ │ │ - zarl, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zgvb uint32 │ │ │ │ + zgvb, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if z.Els == nil && zarl > 0 { │ │ │ │ - z.Els = make(map[string]string, zarl) │ │ │ │ + if z.Els == nil && zgvb > 0 { │ │ │ │ + z.Els = make(map[string]string, zgvb) │ │ │ │ } else if len(z.Els) > 0 { │ │ │ │ for key, _ := range z.Els { │ │ │ │ delete(z.Els, key) │ │ │ │ } │ │ │ │ } │ │ │ │ - for zarl > 0 { │ │ │ │ - var znjj string │ │ │ │ - var zhhj string │ │ │ │ - zarl-- │ │ │ │ - znjj, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zgvb > 0 { │ │ │ │ + var zlur string │ │ │ │ + var zupi string │ │ │ │ + zgvb-- │ │ │ │ + zlur, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - zhhj, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + zupi, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - z.Els[znjj] = zhhj │ │ │ │ + z.Els[zlur] = zupi │ │ │ │ } │ │ │ │ case "object": │ │ │ │ - var zctz uint32 │ │ │ │ - zctz, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zqzg uint32 │ │ │ │ + zqzg, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zctz > 0 { │ │ │ │ - zctz-- │ │ │ │ + for zqzg > 0 { │ │ │ │ + zqzg-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "value_a": │ │ │ │ z.Obj.ValueA, bts, err = msgp.ReadStringBytes(bts) │ │ │ │ @@ -3263,43 +3402,43 @@ │ │ │ │ } │ │ │ │ case "num": │ │ │ │ bts, err = z.Num.UnmarshalMsg(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "Slice1": │ │ │ │ - var zljl uint32 │ │ │ │ - zljl, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zexy uint32 │ │ │ │ + zexy, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice1) >= int(zljl) { │ │ │ │ - z.Slice1 = (z.Slice1)[:zljl] │ │ │ │ + if cap(z.Slice1) >= int(zexy) { │ │ │ │ + z.Slice1 = (z.Slice1)[:zexy] │ │ │ │ } else { │ │ │ │ - z.Slice1 = make([]string, zljl) │ │ │ │ + z.Slice1 = make([]string, zexy) │ │ │ │ } │ │ │ │ - for zuvr := range z.Slice1 { │ │ │ │ - z.Slice1[zuvr], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zfvi := range z.Slice1 { │ │ │ │ + z.Slice1[zfvi], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Slice2": │ │ │ │ - var zziv uint32 │ │ │ │ - zziv, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zakb uint32 │ │ │ │ + zakb, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Slice2) >= int(zziv) { │ │ │ │ - z.Slice2 = (z.Slice2)[:zziv] │ │ │ │ + if cap(z.Slice2) >= int(zakb) { │ │ │ │ + z.Slice2 = (z.Slice2)[:zakb] │ │ │ │ } else { │ │ │ │ - z.Slice2 = make([]string, zziv) │ │ │ │ + z.Slice2 = make([]string, zakb) │ │ │ │ } │ │ │ │ - for zusq := range z.Slice2 { │ │ │ │ - z.Slice2[zusq], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zzrg := range z.Slice2 { │ │ │ │ + z.Slice2[zzrg], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "SlicePtr": │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ bts, err = msgp.ReadNilBytes(bts) │ │ │ │ @@ -3307,26 +3446,26 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ z.SlicePtr = nil │ │ │ │ } else { │ │ │ │ if z.SlicePtr == nil { │ │ │ │ z.SlicePtr = new([]string) │ │ │ │ } │ │ │ │ - var zabj uint32 │ │ │ │ - zabj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zsdj uint32 │ │ │ │ + zsdj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(*z.SlicePtr) >= int(zabj) { │ │ │ │ - *z.SlicePtr = (*z.SlicePtr)[:zabj] │ │ │ │ + if cap(*z.SlicePtr) >= int(zsdj) { │ │ │ │ + *z.SlicePtr = (*z.SlicePtr)[:zsdj] │ │ │ │ } else { │ │ │ │ - *z.SlicePtr = make([]string, zabj) │ │ │ │ + *z.SlicePtr = make([]string, zsdj) │ │ │ │ } │ │ │ │ - for zfgq := range *z.SlicePtr { │ │ │ │ - (*z.SlicePtr)[zfgq], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ + for zbmy := range *z.SlicePtr { │ │ │ │ + (*z.SlicePtr)[zbmy], bts, err = msgp.ReadStringBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ default: │ │ │ │ bts, err = msgp.Skip(bts) │ │ │ │ @@ -3345,111 +3484,111 @@ │ │ │ │ if z.F == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ s += msgp.Float64Size │ │ │ │ } │ │ │ │ s += 9 + msgp.MapHeaderSize │ │ │ │ if z.Els != nil { │ │ │ │ - for znjj, zhhj := range z.Els { │ │ │ │ - _ = zhhj │ │ │ │ - s += msgp.StringPrefixSize + len(znjj) + msgp.StringPrefixSize + len(zhhj) │ │ │ │ + for zlur, zupi := range z.Els { │ │ │ │ + _ = zupi │ │ │ │ + s += msgp.StringPrefixSize + len(zlur) + msgp.StringPrefixSize + len(zupi) │ │ │ │ } │ │ │ │ } │ │ │ │ s += 7 + 1 + 8 + msgp.StringPrefixSize + len(z.Obj.ValueA) + 8 + msgp.BytesPrefixSize + len(z.Obj.ValueB) + 6 │ │ │ │ if z.Child == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ s += z.Child.Msgsize() │ │ │ │ } │ │ │ │ s += 5 + msgp.TimeSize + 4 + msgp.GuessSize(z.Any) + 9 + z.Appended.Msgsize() + 4 + z.Num.Msgsize() + 7 + msgp.ArrayHeaderSize │ │ │ │ - for zuvr := range z.Slice1 { │ │ │ │ - s += msgp.StringPrefixSize + len(z.Slice1[zuvr]) │ │ │ │ + for zfvi := range z.Slice1 { │ │ │ │ + s += msgp.StringPrefixSize + len(z.Slice1[zfvi]) │ │ │ │ } │ │ │ │ s += 7 + msgp.ArrayHeaderSize │ │ │ │ - for zusq := range z.Slice2 { │ │ │ │ - s += msgp.StringPrefixSize + len(z.Slice2[zusq]) │ │ │ │ + for zzrg := range z.Slice2 { │ │ │ │ + s += msgp.StringPrefixSize + len(z.Slice2[zzrg]) │ │ │ │ } │ │ │ │ s += 9 │ │ │ │ if z.SlicePtr == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ s += msgp.ArrayHeaderSize │ │ │ │ - for zfgq := range *z.SlicePtr { │ │ │ │ - s += msgp.StringPrefixSize + len((*z.SlicePtr)[zfgq]) │ │ │ │ + for zbmy := range *z.SlicePtr { │ │ │ │ + s += msgp.StringPrefixSize + len((*z.SlicePtr)[zbmy]) │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Things) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zqzg uint32 │ │ │ │ - zqzg, err = dc.ReadMapHeader() │ │ │ │ + var zdif uint32 │ │ │ │ + zdif, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zqzg > 0 { │ │ │ │ - zqzg-- │ │ │ │ + for zdif > 0 { │ │ │ │ + zdif-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "complex": │ │ │ │ z.Cmplx, err = dc.ReadComplex64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "values": │ │ │ │ - var zexy uint32 │ │ │ │ - zexy, err = dc.ReadArrayHeader() │ │ │ │ + var zibu uint32 │ │ │ │ + zibu, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Vals) >= int(zexy) { │ │ │ │ - z.Vals = (z.Vals)[:zexy] │ │ │ │ + if cap(z.Vals) >= int(zibu) { │ │ │ │ + z.Vals = (z.Vals)[:zibu] │ │ │ │ } else { │ │ │ │ - z.Vals = make([]int32, zexy) │ │ │ │ + z.Vals = make([]int32, zibu) │ │ │ │ } │ │ │ │ - for zmlx := range z.Vals { │ │ │ │ - z.Vals[zmlx], err = dc.ReadInt32() │ │ │ │ + for zsgp := range z.Vals { │ │ │ │ + z.Vals[zsgp], err = dc.ReadInt32() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "arr": │ │ │ │ - var zakb uint32 │ │ │ │ - zakb, err = dc.ReadArrayHeader() │ │ │ │ + var zuff uint32 │ │ │ │ + zuff, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zakb != msgp.ExtensionPrefixSize { │ │ │ │ - err = msgp.ArrayError{Wanted: msgp.ExtensionPrefixSize, Got: zakb} │ │ │ │ + if zuff != msgp.ExtensionPrefixSize { │ │ │ │ + err = msgp.ArrayError{Wanted: msgp.ExtensionPrefixSize, Got: zuff} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zvbw := range z.Arr { │ │ │ │ - z.Arr[zvbw], err = dc.ReadFloat64() │ │ │ │ + for zngc := range z.Arr { │ │ │ │ + z.Arr[zngc], err = dc.ReadFloat64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "arr2": │ │ │ │ - var zsdj uint32 │ │ │ │ - zsdj, err = dc.ReadArrayHeader() │ │ │ │ + var zmow uint32 │ │ │ │ + zmow, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zsdj != 4 { │ │ │ │ - err = msgp.ArrayError{Wanted: 4, Got: zsdj} │ │ │ │ + if zmow != 4 { │ │ │ │ + err = msgp.ArrayError{Wanted: 4, Got: zmow} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zgvb := range z.Arr2 { │ │ │ │ - z.Arr2[zgvb], err = dc.ReadFloat64() │ │ │ │ + for zwfl := range z.Arr2 { │ │ │ │ + z.Arr2[zwfl], err = dc.ReadFloat64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "ext": │ │ │ │ if dc.IsNil() { │ │ │ │ err = dc.ReadNil() │ │ │ │ @@ -3498,46 +3637,46 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Vals))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zmlx := range z.Vals { │ │ │ │ - err = en.WriteInt32(z.Vals[zmlx]) │ │ │ │ + for zsgp := range z.Vals { │ │ │ │ + err = en.WriteInt32(z.Vals[zsgp]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "arr" │ │ │ │ err = en.Append(0xa3, 0x61, 0x72, 0x72) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(msgp.ExtensionPrefixSize) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zvbw := range z.Arr { │ │ │ │ - err = en.WriteFloat64(z.Arr[zvbw]) │ │ │ │ + for zngc := range z.Arr { │ │ │ │ + err = en.WriteFloat64(z.Arr[zngc]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "arr2" │ │ │ │ err = en.Append(0xa4, 0x61, 0x72, 0x72, 0x32) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(4) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zgvb := range z.Arr2 { │ │ │ │ - err = en.WriteFloat64(z.Arr2[zgvb]) │ │ │ │ + for zwfl := range z.Arr2 { │ │ │ │ + err = en.WriteFloat64(z.Arr2[zwfl]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "ext" │ │ │ │ err = en.Append(0xa3, 0x65, 0x78, 0x74) │ │ │ │ if err != nil { │ │ │ │ @@ -3572,28 +3711,28 @@ │ │ │ │ // map header, size 6 │ │ │ │ // string "complex" │ │ │ │ o = append(o, 0x86, 0xa7, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78) │ │ │ │ o = msgp.AppendComplex64(o, z.Cmplx) │ │ │ │ // string "values" │ │ │ │ o = append(o, 0xa6, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Vals))) │ │ │ │ - for zmlx := range z.Vals { │ │ │ │ - o = msgp.AppendInt32(o, z.Vals[zmlx]) │ │ │ │ + for zsgp := range z.Vals { │ │ │ │ + o = msgp.AppendInt32(o, z.Vals[zsgp]) │ │ │ │ } │ │ │ │ // string "arr" │ │ │ │ o = append(o, 0xa3, 0x61, 0x72, 0x72) │ │ │ │ o = msgp.AppendArrayHeader(o, msgp.ExtensionPrefixSize) │ │ │ │ - for zvbw := range z.Arr { │ │ │ │ - o = msgp.AppendFloat64(o, z.Arr[zvbw]) │ │ │ │ + for zngc := range z.Arr { │ │ │ │ + o = msgp.AppendFloat64(o, z.Arr[zngc]) │ │ │ │ } │ │ │ │ // string "arr2" │ │ │ │ o = append(o, 0xa4, 0x61, 0x72, 0x72, 0x32) │ │ │ │ o = msgp.AppendArrayHeader(o, 4) │ │ │ │ - for zgvb := range z.Arr2 { │ │ │ │ - o = msgp.AppendFloat64(o, z.Arr2[zgvb]) │ │ │ │ + for zwfl := range z.Arr2 { │ │ │ │ + o = msgp.AppendFloat64(o, z.Arr2[zwfl]) │ │ │ │ } │ │ │ │ // string "ext" │ │ │ │ o = append(o, 0xa3, 0x65, 0x78, 0x74) │ │ │ │ if z.Ext == nil { │ │ │ │ o = msgp.AppendNil(o) │ │ │ │ } else { │ │ │ │ o, err = msgp.AppendExtension(o, z.Ext) │ │ │ │ @@ -3610,76 +3749,76 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Things) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zsgp uint32 │ │ │ │ - zsgp, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zdit uint32 │ │ │ │ + zdit, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zsgp > 0 { │ │ │ │ - zsgp-- │ │ │ │ + for zdit > 0 { │ │ │ │ + zdit-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "complex": │ │ │ │ z.Cmplx, bts, err = msgp.ReadComplex64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "values": │ │ │ │ - var zngc uint32 │ │ │ │ - zngc, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zslz uint32 │ │ │ │ + zslz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Vals) >= int(zngc) { │ │ │ │ - z.Vals = (z.Vals)[:zngc] │ │ │ │ + if cap(z.Vals) >= int(zslz) { │ │ │ │ + z.Vals = (z.Vals)[:zslz] │ │ │ │ } else { │ │ │ │ - z.Vals = make([]int32, zngc) │ │ │ │ + z.Vals = make([]int32, zslz) │ │ │ │ } │ │ │ │ - for zmlx := range z.Vals { │ │ │ │ - z.Vals[zmlx], bts, err = msgp.ReadInt32Bytes(bts) │ │ │ │ + for zsgp := range z.Vals { │ │ │ │ + z.Vals[zsgp], bts, err = msgp.ReadInt32Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "arr": │ │ │ │ - var zwfl uint32 │ │ │ │ - zwfl, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zoqj uint32 │ │ │ │ + zoqj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zwfl != msgp.ExtensionPrefixSize { │ │ │ │ - err = msgp.ArrayError{Wanted: msgp.ExtensionPrefixSize, Got: zwfl} │ │ │ │ + if zoqj != msgp.ExtensionPrefixSize { │ │ │ │ + err = msgp.ArrayError{Wanted: msgp.ExtensionPrefixSize, Got: zoqj} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zvbw := range z.Arr { │ │ │ │ - z.Arr[zvbw], bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ + for zngc := range z.Arr { │ │ │ │ + z.Arr[zngc], bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "arr2": │ │ │ │ - var zdif uint32 │ │ │ │ - zdif, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zmqr uint32 │ │ │ │ + zmqr, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zdif != 4 { │ │ │ │ - err = msgp.ArrayError{Wanted: 4, Got: zdif} │ │ │ │ + if zmqr != 4 { │ │ │ │ + err = msgp.ArrayError{Wanted: 4, Got: zmqr} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zgvb := range z.Arr2 { │ │ │ │ - z.Arr2[zgvb], bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ + for zwfl := range z.Arr2 { │ │ │ │ + z.Arr2[zwfl], bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "ext": │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ bts, err = msgp.ReadNilBytes(bts) │ │ │ │ @@ -3724,39 +3863,39 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Tree) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zuff uint32 │ │ │ │ - zuff, err = dc.ReadMapHeader() │ │ │ │ + var ztoj uint32 │ │ │ │ + ztoj, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zuff > 0 { │ │ │ │ - zuff-- │ │ │ │ + for ztoj > 0 { │ │ │ │ + ztoj-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Children": │ │ │ │ - var zmow uint32 │ │ │ │ - zmow, err = dc.ReadArrayHeader() │ │ │ │ + var ziyx uint32 │ │ │ │ + ziyx, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Children) >= int(zmow) { │ │ │ │ - z.Children = (z.Children)[:zmow] │ │ │ │ + if cap(z.Children) >= int(ziyx) { │ │ │ │ + z.Children = (z.Children)[:ziyx] │ │ │ │ } else { │ │ │ │ - z.Children = make([]Tree, zmow) │ │ │ │ + z.Children = make([]Tree, ziyx) │ │ │ │ } │ │ │ │ - for zibu := range z.Children { │ │ │ │ - err = z.Children[zibu].DecodeMsg(dc) │ │ │ │ + for ztic := range z.Children { │ │ │ │ + err = z.Children[ztic].DecodeMsg(dc) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Element": │ │ │ │ z.Element, err = dc.ReadInt() │ │ │ │ if err != nil { │ │ │ │ @@ -3769,21 +3908,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ z.Parent = nil │ │ │ │ } else { │ │ │ │ if z.Parent == nil { │ │ │ │ z.Parent = new(Wrapper) │ │ │ │ } │ │ │ │ - var zdit uint32 │ │ │ │ - zdit, err = dc.ReadMapHeader() │ │ │ │ + var zyes uint32 │ │ │ │ + zyes, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zdit > 0 { │ │ │ │ - zdit-- │ │ │ │ + for zyes > 0 { │ │ │ │ + zyes-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Tree": │ │ │ │ if dc.IsNil() { │ │ │ │ @@ -3827,16 +3966,16 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Children))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zibu := range z.Children { │ │ │ │ - err = z.Children[zibu].EncodeMsg(en) │ │ │ │ + for ztic := range z.Children { │ │ │ │ + err = z.Children[ztic].EncodeMsg(en) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // write "Element" │ │ │ │ err = en.Append(0xa7, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74) │ │ │ │ if err != nil { │ │ │ │ @@ -3881,16 +4020,16 @@ │ │ │ │ // MarshalMsg implements msgp.Marshaler │ │ │ │ func (z *Tree) MarshalMsg(b []byte) (o []byte, err error) { │ │ │ │ o = msgp.Require(b, z.Msgsize()) │ │ │ │ // map header, size 3 │ │ │ │ // string "Children" │ │ │ │ o = append(o, 0x83, 0xa8, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Children))) │ │ │ │ - for zibu := range z.Children { │ │ │ │ - o, err = z.Children[zibu].MarshalMsg(o) │ │ │ │ + for ztic := range z.Children { │ │ │ │ + o, err = z.Children[ztic].MarshalMsg(o) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ // string "Element" │ │ │ │ o = append(o, 0xa7, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74) │ │ │ │ o = msgp.AppendInt(o, z.Element) │ │ │ │ @@ -3914,39 +4053,39 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Tree) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zslz uint32 │ │ │ │ - zslz, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zxzy uint32 │ │ │ │ + zxzy, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zslz > 0 { │ │ │ │ - zslz-- │ │ │ │ + for zxzy > 0 { │ │ │ │ + zxzy-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Children": │ │ │ │ - var zoqj uint32 │ │ │ │ - zoqj, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zfro uint32 │ │ │ │ + zfro, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Children) >= int(zoqj) { │ │ │ │ - z.Children = (z.Children)[:zoqj] │ │ │ │ + if cap(z.Children) >= int(zfro) { │ │ │ │ + z.Children = (z.Children)[:zfro] │ │ │ │ } else { │ │ │ │ - z.Children = make([]Tree, zoqj) │ │ │ │ + z.Children = make([]Tree, zfro) │ │ │ │ } │ │ │ │ - for zibu := range z.Children { │ │ │ │ - bts, err = z.Children[zibu].UnmarshalMsg(bts) │ │ │ │ + for ztic := range z.Children { │ │ │ │ + bts, err = z.Children[ztic].UnmarshalMsg(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ case "Element": │ │ │ │ z.Element, bts, err = msgp.ReadIntBytes(bts) │ │ │ │ if err != nil { │ │ │ │ @@ -3959,21 +4098,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ z.Parent = nil │ │ │ │ } else { │ │ │ │ if z.Parent == nil { │ │ │ │ z.Parent = new(Wrapper) │ │ │ │ } │ │ │ │ - var zmqr uint32 │ │ │ │ - zmqr, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zrod uint32 │ │ │ │ + zrod, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zmqr > 0 { │ │ │ │ - zmqr-- │ │ │ │ + for zrod > 0 { │ │ │ │ + zrod-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Tree": │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ @@ -4009,16 +4148,16 @@ │ │ │ │ o = bts │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message │ │ │ │ func (z *Tree) Msgsize() (s int) { │ │ │ │ s = 1 + 9 + msgp.ArrayHeaderSize │ │ │ │ - for zibu := range z.Children { │ │ │ │ - s += z.Children[zibu].Msgsize() │ │ │ │ + for ztic := range z.Children { │ │ │ │ + s += z.Children[ztic].Msgsize() │ │ │ │ } │ │ │ │ s += 8 + msgp.IntSize + 7 │ │ │ │ if z.Parent == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ s += 1 + 5 │ │ │ │ if z.Parent.Tree == nil { │ │ │ │ @@ -4030,21 +4169,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *Wrapper) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var ztic uint32 │ │ │ │ - ztic, err = dc.ReadMapHeader() │ │ │ │ + var zmbn uint32 │ │ │ │ + zmbn, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for ztic > 0 { │ │ │ │ - ztic-- │ │ │ │ + for zmbn > 0 { │ │ │ │ + zmbn-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Tree": │ │ │ │ if dc.IsNil() { │ │ │ │ @@ -4111,21 +4250,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *Wrapper) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var ztoj uint32 │ │ │ │ - ztoj, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zdrz uint32 │ │ │ │ + zdrz, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for ztoj > 0 { │ │ │ │ - ztoj-- │ │ │ │ + for zdrz > 0 { │ │ │ │ + zdrz-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Tree": │ │ │ │ if msgp.IsNil(bts) { │ │ │ │ @@ -4165,21 +4304,21 @@ │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // DecodeMsg implements msgp.Decodable │ │ │ │ func (z *X) DecodeMsg(dc *msgp.Reader) (err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zrwc uint32 │ │ │ │ - zrwc, err = dc.ReadMapHeader() │ │ │ │ + var zaps uint32 │ │ │ │ + zaps, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zrwc > 0 { │ │ │ │ - zrwc-- │ │ │ │ + for zaps > 0 { │ │ │ │ + zaps-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Values": │ │ │ │ err = dc.ReadExactBytes((z.Values)[:]) │ │ │ │ @@ -4204,101 +4343,101 @@ │ │ │ │ } │ │ │ │ case "More": │ │ │ │ err = dc.ReadExactBytes((z.More)[:]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "Others": │ │ │ │ - var zjpm uint32 │ │ │ │ - zjpm, err = dc.ReadArrayHeader() │ │ │ │ + var zvgz uint32 │ │ │ │ + zvgz, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Others) >= int(zjpm) { │ │ │ │ - z.Others = (z.Others)[:zjpm] │ │ │ │ + if cap(z.Others) >= int(zvgz) { │ │ │ │ + z.Others = (z.Others)[:zvgz] │ │ │ │ } else { │ │ │ │ - z.Others = make([][32]int32, zjpm) │ │ │ │ + z.Others = make([][32]int32, zvgz) │ │ │ │ } │ │ │ │ - for zfro := range z.Others { │ │ │ │ - var zhdt uint32 │ │ │ │ - zhdt, err = dc.ReadArrayHeader() │ │ │ │ + for zhdt := range z.Others { │ │ │ │ + var zhbk uint32 │ │ │ │ + zhbk, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zhdt != 32 { │ │ │ │ - err = msgp.ArrayError{Wanted: 32, Got: zhdt} │ │ │ │ + if zhbk != 32 { │ │ │ │ + err = msgp.ArrayError{Wanted: 32, Got: zhbk} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zrod := range z.Others[zfro] { │ │ │ │ - z.Others[zfro][zrod], err = dc.ReadInt32() │ │ │ │ + for zjmh := range z.Others[zhdt] { │ │ │ │ + z.Others[zhdt][zjmh], err = dc.ReadInt32() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "Matrix": │ │ │ │ - var zjmh uint32 │ │ │ │ - zjmh, err = dc.ReadArrayHeader() │ │ │ │ + var zmyy uint32 │ │ │ │ + zmyy, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Matrix) >= int(zjmh) { │ │ │ │ - z.Matrix = (z.Matrix)[:zjmh] │ │ │ │ + if cap(z.Matrix) >= int(zmyy) { │ │ │ │ + z.Matrix = (z.Matrix)[:zmyy] │ │ │ │ } else { │ │ │ │ - z.Matrix = make([][]int32, zjmh) │ │ │ │ + z.Matrix = make([][]int32, zmyy) │ │ │ │ } │ │ │ │ - for zmbn := range z.Matrix { │ │ │ │ - var zayo uint32 │ │ │ │ - zayo, err = dc.ReadArrayHeader() │ │ │ │ + for zayo := range z.Matrix { │ │ │ │ + var ztej uint32 │ │ │ │ + ztej, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Matrix[zmbn]) >= int(zayo) { │ │ │ │ - z.Matrix[zmbn] = (z.Matrix[zmbn])[:zayo] │ │ │ │ + if cap(z.Matrix[zayo]) >= int(ztej) { │ │ │ │ + z.Matrix[zayo] = (z.Matrix[zayo])[:ztej] │ │ │ │ } else { │ │ │ │ - z.Matrix[zmbn] = make([]int32, zayo) │ │ │ │ + z.Matrix[zayo] = make([]int32, ztej) │ │ │ │ } │ │ │ │ - for zdrz := range z.Matrix[zmbn] { │ │ │ │ - z.Matrix[zmbn][zdrz], err = dc.ReadInt32() │ │ │ │ + for zrsu := range z.Matrix[zayo] { │ │ │ │ + z.Matrix[zayo][zrsu], err = dc.ReadInt32() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "ManyFixed": │ │ │ │ - var zrsu uint32 │ │ │ │ - zrsu, err = dc.ReadArrayHeader() │ │ │ │ + var zvgw uint32 │ │ │ │ + zvgw, err = dc.ReadArrayHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.ManyFixed) >= int(zrsu) { │ │ │ │ - z.ManyFixed = (z.ManyFixed)[:zrsu] │ │ │ │ + if cap(z.ManyFixed) >= int(zvgw) { │ │ │ │ + z.ManyFixed = (z.ManyFixed)[:zvgw] │ │ │ │ } else { │ │ │ │ - z.ManyFixed = make([]Fixed, zrsu) │ │ │ │ + z.ManyFixed = make([]Fixed, zvgw) │ │ │ │ } │ │ │ │ - for znpn := range z.ManyFixed { │ │ │ │ - var zfum uint32 │ │ │ │ - zfum, err = dc.ReadMapHeader() │ │ │ │ + for zfum := range z.ManyFixed { │ │ │ │ + var zffb uint32 │ │ │ │ + zffb, err = dc.ReadMapHeader() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zfum > 0 { │ │ │ │ - zfum-- │ │ │ │ + for zffb > 0 { │ │ │ │ + zffb-- │ │ │ │ field, err = dc.ReadMapKeyPtr() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ - z.ManyFixed[znpn].A, err = dc.ReadFloat64() │ │ │ │ + z.ManyFixed[zfum].A, err = dc.ReadFloat64() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "B": │ │ │ │ - z.ManyFixed[znpn].B, err = dc.ReadBool() │ │ │ │ + z.ManyFixed[zfum].B, err = dc.ReadBool() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ default: │ │ │ │ err = dc.Skip() │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ @@ -4358,73 +4497,73 @@ │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Others))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zfro := range z.Others { │ │ │ │ + for zhdt := range z.Others { │ │ │ │ err = en.WriteArrayHeader(32) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zrod := range z.Others[zfro] { │ │ │ │ - err = en.WriteInt32(z.Others[zfro][zrod]) │ │ │ │ + for zjmh := range z.Others[zhdt] { │ │ │ │ + err = en.WriteInt32(z.Others[zhdt][zjmh]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ // write "Matrix" │ │ │ │ err = en.Append(0xa6, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.Matrix))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zmbn := range z.Matrix { │ │ │ │ - err = en.WriteArrayHeader(uint32(len(z.Matrix[zmbn]))) │ │ │ │ + for zayo := range z.Matrix { │ │ │ │ + err = en.WriteArrayHeader(uint32(len(z.Matrix[zayo]))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zdrz := range z.Matrix[zmbn] { │ │ │ │ - err = en.WriteInt32(z.Matrix[zmbn][zdrz]) │ │ │ │ + for zrsu := range z.Matrix[zayo] { │ │ │ │ + err = en.WriteInt32(z.Matrix[zayo][zrsu]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ // write "ManyFixed" │ │ │ │ err = en.Append(0xa9, 0x4d, 0x61, 0x6e, 0x79, 0x46, 0x69, 0x78, 0x65, 0x64) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ err = en.WriteArrayHeader(uint32(len(z.ManyFixed))) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for znpn := range z.ManyFixed { │ │ │ │ + for zfum := range z.ManyFixed { │ │ │ │ // map header, size 2 │ │ │ │ // write "A" │ │ │ │ err = en.Append(0x82, 0xa1, 0x41) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ - err = en.WriteFloat64(z.ManyFixed[znpn].A) │ │ │ │ + err = en.WriteFloat64(z.ManyFixed[zfum].A) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ // write "B" │ │ │ │ err = en.Append(0xa1, 0x42) │ │ │ │ if err != nil { │ │ │ │ return err │ │ │ │ } │ │ │ │ - err = en.WriteBool(z.ManyFixed[znpn].B) │ │ │ │ + err = en.WriteBool(z.ManyFixed[zfum].B) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ @@ -4444,55 +4583,55 @@ │ │ │ │ } │ │ │ │ // string "More" │ │ │ │ o = append(o, 0xa4, 0x4d, 0x6f, 0x72, 0x65) │ │ │ │ o = msgp.AppendBytes(o, (z.More)[:]) │ │ │ │ // string "Others" │ │ │ │ o = append(o, 0xa6, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x73) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Others))) │ │ │ │ - for zfro := range z.Others { │ │ │ │ + for zhdt := range z.Others { │ │ │ │ o = msgp.AppendArrayHeader(o, 32) │ │ │ │ - for zrod := range z.Others[zfro] { │ │ │ │ - o = msgp.AppendInt32(o, z.Others[zfro][zrod]) │ │ │ │ + for zjmh := range z.Others[zhdt] { │ │ │ │ + o = msgp.AppendInt32(o, z.Others[zhdt][zjmh]) │ │ │ │ } │ │ │ │ } │ │ │ │ // string "Matrix" │ │ │ │ o = append(o, 0xa6, 0x4d, 0x61, 0x74, 0x72, 0x69, 0x78) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.Matrix))) │ │ │ │ - for zmbn := range z.Matrix { │ │ │ │ - o = msgp.AppendArrayHeader(o, uint32(len(z.Matrix[zmbn]))) │ │ │ │ - for zdrz := range z.Matrix[zmbn] { │ │ │ │ - o = msgp.AppendInt32(o, z.Matrix[zmbn][zdrz]) │ │ │ │ + for zayo := range z.Matrix { │ │ │ │ + o = msgp.AppendArrayHeader(o, uint32(len(z.Matrix[zayo]))) │ │ │ │ + for zrsu := range z.Matrix[zayo] { │ │ │ │ + o = msgp.AppendInt32(o, z.Matrix[zayo][zrsu]) │ │ │ │ } │ │ │ │ } │ │ │ │ // string "ManyFixed" │ │ │ │ o = append(o, 0xa9, 0x4d, 0x61, 0x6e, 0x79, 0x46, 0x69, 0x78, 0x65, 0x64) │ │ │ │ o = msgp.AppendArrayHeader(o, uint32(len(z.ManyFixed))) │ │ │ │ - for znpn := range z.ManyFixed { │ │ │ │ + for zfum := range z.ManyFixed { │ │ │ │ // map header, size 2 │ │ │ │ // string "A" │ │ │ │ o = append(o, 0x82, 0xa1, 0x41) │ │ │ │ - o = msgp.AppendFloat64(o, z.ManyFixed[znpn].A) │ │ │ │ + o = msgp.AppendFloat64(o, z.ManyFixed[zfum].A) │ │ │ │ // string "B" │ │ │ │ o = append(o, 0xa1, 0x42) │ │ │ │ - o = msgp.AppendBool(o, z.ManyFixed[znpn].B) │ │ │ │ + o = msgp.AppendBool(o, z.ManyFixed[zfum].B) │ │ │ │ } │ │ │ │ return │ │ │ │ } │ │ │ │ │ │ │ │ // UnmarshalMsg implements msgp.Unmarshaler │ │ │ │ func (z *X) UnmarshalMsg(bts []byte) (o []byte, err error) { │ │ │ │ var field []byte │ │ │ │ _ = field │ │ │ │ - var zaps uint32 │ │ │ │ - zaps, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + var zbgg uint32 │ │ │ │ + zbgg, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zaps > 0 { │ │ │ │ - zaps-- │ │ │ │ + for zbgg > 0 { │ │ │ │ + zbgg-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "Values": │ │ │ │ bts, err = msgp.ReadExactBytes(bts, (z.Values)[:]) │ │ │ │ @@ -4517,101 +4656,101 @@ │ │ │ │ } │ │ │ │ case "More": │ │ │ │ bts, err = msgp.ReadExactBytes(bts, (z.More)[:]) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "Others": │ │ │ │ - var zvgz uint32 │ │ │ │ - zvgz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zcnq uint32 │ │ │ │ + zcnq, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Others) >= int(zvgz) { │ │ │ │ - z.Others = (z.Others)[:zvgz] │ │ │ │ + if cap(z.Others) >= int(zcnq) { │ │ │ │ + z.Others = (z.Others)[:zcnq] │ │ │ │ } else { │ │ │ │ - z.Others = make([][32]int32, zvgz) │ │ │ │ + z.Others = make([][32]int32, zcnq) │ │ │ │ } │ │ │ │ - for zfro := range z.Others { │ │ │ │ - var zhbk uint32 │ │ │ │ - zhbk, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + for zhdt := range z.Others { │ │ │ │ + var zbae uint32 │ │ │ │ + zbae, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if zhbk != 32 { │ │ │ │ - err = msgp.ArrayError{Wanted: 32, Got: zhbk} │ │ │ │ + if zbae != 32 { │ │ │ │ + err = msgp.ArrayError{Wanted: 32, Got: zbae} │ │ │ │ return │ │ │ │ } │ │ │ │ - for zrod := range z.Others[zfro] { │ │ │ │ - z.Others[zfro][zrod], bts, err = msgp.ReadInt32Bytes(bts) │ │ │ │ + for zjmh := range z.Others[zhdt] { │ │ │ │ + z.Others[zhdt][zjmh], bts, err = msgp.ReadInt32Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "Matrix": │ │ │ │ - var zmyy uint32 │ │ │ │ - zmyy, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zreu uint32 │ │ │ │ + zreu, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Matrix) >= int(zmyy) { │ │ │ │ - z.Matrix = (z.Matrix)[:zmyy] │ │ │ │ + if cap(z.Matrix) >= int(zreu) { │ │ │ │ + z.Matrix = (z.Matrix)[:zreu] │ │ │ │ } else { │ │ │ │ - z.Matrix = make([][]int32, zmyy) │ │ │ │ + z.Matrix = make([][]int32, zreu) │ │ │ │ } │ │ │ │ - for zmbn := range z.Matrix { │ │ │ │ - var ztej uint32 │ │ │ │ - ztej, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + for zayo := range z.Matrix { │ │ │ │ + var znuz uint32 │ │ │ │ + znuz, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.Matrix[zmbn]) >= int(ztej) { │ │ │ │ - z.Matrix[zmbn] = (z.Matrix[zmbn])[:ztej] │ │ │ │ + if cap(z.Matrix[zayo]) >= int(znuz) { │ │ │ │ + z.Matrix[zayo] = (z.Matrix[zayo])[:znuz] │ │ │ │ } else { │ │ │ │ - z.Matrix[zmbn] = make([]int32, ztej) │ │ │ │ + z.Matrix[zayo] = make([]int32, znuz) │ │ │ │ } │ │ │ │ - for zdrz := range z.Matrix[zmbn] { │ │ │ │ - z.Matrix[zmbn][zdrz], bts, err = msgp.ReadInt32Bytes(bts) │ │ │ │ + for zrsu := range z.Matrix[zayo] { │ │ │ │ + z.Matrix[zayo][zrsu], bts, err = msgp.ReadInt32Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ } │ │ │ │ } │ │ │ │ case "ManyFixed": │ │ │ │ - var zvgw uint32 │ │ │ │ - zvgw, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ + var zjqx uint32 │ │ │ │ + zjqx, bts, err = msgp.ReadArrayHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - if cap(z.ManyFixed) >= int(zvgw) { │ │ │ │ - z.ManyFixed = (z.ManyFixed)[:zvgw] │ │ │ │ + if cap(z.ManyFixed) >= int(zjqx) { │ │ │ │ + z.ManyFixed = (z.ManyFixed)[:zjqx] │ │ │ │ } else { │ │ │ │ - z.ManyFixed = make([]Fixed, zvgw) │ │ │ │ + z.ManyFixed = make([]Fixed, zjqx) │ │ │ │ } │ │ │ │ - for znpn := range z.ManyFixed { │ │ │ │ - var zffb uint32 │ │ │ │ - zffb, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ + for zfum := range z.ManyFixed { │ │ │ │ + var zmzo uint32 │ │ │ │ + zmzo, bts, err = msgp.ReadMapHeaderBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ - for zffb > 0 { │ │ │ │ - zffb-- │ │ │ │ + for zmzo > 0 { │ │ │ │ + zmzo-- │ │ │ │ field, bts, err = msgp.ReadMapKeyZC(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ switch msgp.UnsafeString(field) { │ │ │ │ case "A": │ │ │ │ - z.ManyFixed[znpn].A, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ + z.ManyFixed[zfum].A, bts, err = msgp.ReadFloat64Bytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ case "B": │ │ │ │ - z.ManyFixed[znpn].B, bts, err = msgp.ReadBoolBytes(bts) │ │ │ │ + z.ManyFixed[zfum].B, bts, err = msgp.ReadBoolBytes(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ } │ │ │ │ default: │ │ │ │ bts, err = msgp.Skip(bts) │ │ │ │ if err != nil { │ │ │ │ return │ │ │ │ @@ -4635,13 +4774,13 @@ │ │ │ │ s = 1 + 7 + msgp.ArrayHeaderSize + (32 * (msgp.ByteSize)) + 10 │ │ │ │ if z.ValuesPtr == nil { │ │ │ │ s += msgp.NilSize │ │ │ │ } else { │ │ │ │ s += msgp.ArrayHeaderSize + (32 * (msgp.ByteSize)) │ │ │ │ } │ │ │ │ s += 5 + msgp.ArrayHeaderSize + (32 * (msgp.ByteSize)) + 7 + msgp.ArrayHeaderSize + (len(z.Others) * (32 * (msgp.Int32Size))) + 7 + msgp.ArrayHeaderSize │ │ │ │ - for zmbn := range z.Matrix { │ │ │ │ - s += msgp.ArrayHeaderSize + (len(z.Matrix[zmbn]) * (msgp.Int32Size)) │ │ │ │ + for zayo := range z.Matrix { │ │ │ │ + s += msgp.ArrayHeaderSize + (len(z.Matrix[zayo]) * (msgp.Int32Size)) │ │ │ │ } │ │ │ │ s += 10 + msgp.ArrayHeaderSize + (len(z.ManyFixed) * (5 + msgp.Float64Size + msgp.BoolSize)) │ │ │ │ return │ │ │ │ }