1
2
3
4 package proto2_maps
5
6 import (
7 bytes "bytes"
8 compress_gzip "compress/gzip"
9 encoding_binary "encoding/binary"
10 fmt "fmt"
11 _ "github.com/gogo/protobuf/gogoproto"
12 github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
13 proto "github.com/gogo/protobuf/proto"
14 github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
15 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
16 github_com_gogo_protobuf_test "github.com/gogo/protobuf/test"
17 github_com_gogo_protobuf_test_custom "github.com/gogo/protobuf/test/custom"
18 io "io"
19 io_ioutil "io/ioutil"
20 math "math"
21 math_bits "math/bits"
22 reflect "reflect"
23 strconv "strconv"
24 strings "strings"
25 )
26
27
28 var _ = proto.Marshal
29 var _ = fmt.Errorf
30 var _ = math.Inf
31
32
33
34
35
36 const _ = proto.GoGoProtoPackageIsVersion3
37
38 type MapEnum int32
39
40 const (
41 MA MapEnum = 0
42 MB MapEnum = 1
43 MC MapEnum = 2
44 )
45
46 var MapEnum_name = map[int32]string{
47 0: "MA",
48 1: "MB",
49 2: "MC",
50 }
51
52 var MapEnum_value = map[string]int32{
53 "MA": 0,
54 "MB": 1,
55 "MC": 2,
56 }
57
58 func (x MapEnum) Enum() *MapEnum {
59 p := new(MapEnum)
60 *p = x
61 return p
62 }
63
64 func (x MapEnum) MarshalJSON() ([]byte, error) {
65 return proto.MarshalJSONEnum(MapEnum_name, int32(x))
66 }
67
68 func (x *MapEnum) UnmarshalJSON(data []byte) error {
69 value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum")
70 if err != nil {
71 return err
72 }
73 *x = MapEnum(value)
74 return nil
75 }
76
77 func (MapEnum) EnumDescriptor() ([]byte, []int) {
78 return fileDescriptor_6f53681484260870, []int{0}
79 }
80
81 type FloatingPoint struct {
82 F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"`
83 XXX_NoUnkeyedLiteral struct{} `json:"-"`
84 XXX_unrecognized []byte `json:"-"`
85 XXX_sizecache int32 `json:"-"`
86 }
87
88 func (m *FloatingPoint) Reset() { *m = FloatingPoint{} }
89 func (*FloatingPoint) ProtoMessage() {}
90 func (*FloatingPoint) Descriptor() ([]byte, []int) {
91 return fileDescriptor_6f53681484260870, []int{0}
92 }
93 func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
94 return m.Unmarshal(b)
95 }
96 func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
97 return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
98 }
99 func (m *FloatingPoint) XXX_Merge(src proto.Message) {
100 xxx_messageInfo_FloatingPoint.Merge(m, src)
101 }
102 func (m *FloatingPoint) XXX_Size() int {
103 return xxx_messageInfo_FloatingPoint.Size(m)
104 }
105 func (m *FloatingPoint) XXX_DiscardUnknown() {
106 xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
107 }
108
109 var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo
110
111 type CustomMap struct {
112 Nullable128S map[string]*github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,1,rep,name=Nullable128s,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Nullable128s,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
113 Uint128S map[string]github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Uint128s,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Uint128s" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
114 NullableIds map[string]*github_com_gogo_protobuf_test.Uuid `protobuf:"bytes,3,rep,name=NullableIds,customtype=github.com/gogo/protobuf/test.Uuid" json:"NullableIds,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
115 Ids map[string]github_com_gogo_protobuf_test.Uuid `protobuf:"bytes,4,rep,name=Ids,customtype=github.com/gogo/protobuf/test.Uuid" json:"Ids" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
116 XXX_NoUnkeyedLiteral struct{} `json:"-"`
117 XXX_unrecognized []byte `json:"-"`
118 XXX_sizecache int32 `json:"-"`
119 }
120
121 func (m *CustomMap) Reset() { *m = CustomMap{} }
122 func (*CustomMap) ProtoMessage() {}
123 func (*CustomMap) Descriptor() ([]byte, []int) {
124 return fileDescriptor_6f53681484260870, []int{1}
125 }
126 func (m *CustomMap) XXX_Unmarshal(b []byte) error {
127 return m.Unmarshal(b)
128 }
129 func (m *CustomMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
130 return xxx_messageInfo_CustomMap.Marshal(b, m, deterministic)
131 }
132 func (m *CustomMap) XXX_Merge(src proto.Message) {
133 xxx_messageInfo_CustomMap.Merge(m, src)
134 }
135 func (m *CustomMap) XXX_Size() int {
136 return xxx_messageInfo_CustomMap.Size(m)
137 }
138 func (m *CustomMap) XXX_DiscardUnknown() {
139 xxx_messageInfo_CustomMap.DiscardUnknown(m)
140 }
141
142 var xxx_messageInfo_CustomMap proto.InternalMessageInfo
143
144 type AllMaps struct {
145 StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
146 StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
147 Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
148 Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
149 Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
150 Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
151 Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
152 Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
153 Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
154 Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
155 Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
156 Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
157 BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
158 StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
159 StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
160 StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"`
161 StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
162 XXX_NoUnkeyedLiteral struct{} `json:"-"`
163 XXX_unrecognized []byte `json:"-"`
164 XXX_sizecache int32 `json:"-"`
165 }
166
167 func (m *AllMaps) Reset() { *m = AllMaps{} }
168 func (*AllMaps) ProtoMessage() {}
169 func (*AllMaps) Descriptor() ([]byte, []int) {
170 return fileDescriptor_6f53681484260870, []int{2}
171 }
172 func (m *AllMaps) XXX_Unmarshal(b []byte) error {
173 return m.Unmarshal(b)
174 }
175 func (m *AllMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
176 return xxx_messageInfo_AllMaps.Marshal(b, m, deterministic)
177 }
178 func (m *AllMaps) XXX_Merge(src proto.Message) {
179 xxx_messageInfo_AllMaps.Merge(m, src)
180 }
181 func (m *AllMaps) XXX_Size() int {
182 return xxx_messageInfo_AllMaps.Size(m)
183 }
184 func (m *AllMaps) XXX_DiscardUnknown() {
185 xxx_messageInfo_AllMaps.DiscardUnknown(m)
186 }
187
188 var xxx_messageInfo_AllMaps proto.InternalMessageInfo
189
190 type AllMapsOrdered struct {
191 StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
192 StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
193 Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
194 Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
195 Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
196 Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
197 Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
198 Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
199 Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
200 Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
201 Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
202 Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
203 BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
204 StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
205 StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
206 StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"`
207 StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
208 XXX_NoUnkeyedLiteral struct{} `json:"-"`
209 XXX_unrecognized []byte `json:"-"`
210 XXX_sizecache int32 `json:"-"`
211 }
212
213 func (m *AllMapsOrdered) Reset() { *m = AllMapsOrdered{} }
214 func (*AllMapsOrdered) ProtoMessage() {}
215 func (*AllMapsOrdered) Descriptor() ([]byte, []int) {
216 return fileDescriptor_6f53681484260870, []int{3}
217 }
218 func (m *AllMapsOrdered) XXX_Unmarshal(b []byte) error {
219 return m.Unmarshal(b)
220 }
221 func (m *AllMapsOrdered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
222 return xxx_messageInfo_AllMapsOrdered.Marshal(b, m, deterministic)
223 }
224 func (m *AllMapsOrdered) XXX_Merge(src proto.Message) {
225 xxx_messageInfo_AllMapsOrdered.Merge(m, src)
226 }
227 func (m *AllMapsOrdered) XXX_Size() int {
228 return xxx_messageInfo_AllMapsOrdered.Size(m)
229 }
230 func (m *AllMapsOrdered) XXX_DiscardUnknown() {
231 xxx_messageInfo_AllMapsOrdered.DiscardUnknown(m)
232 }
233
234 var xxx_messageInfo_AllMapsOrdered proto.InternalMessageInfo
235
236 func init() {
237 proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value)
238 proto.RegisterType((*FloatingPoint)(nil), "proto2.maps.FloatingPoint")
239 proto.RegisterType((*CustomMap)(nil), "proto2.maps.CustomMap")
240 proto.RegisterMapType((map[string]github_com_gogo_protobuf_test.Uuid)(nil), "proto2.maps.CustomMap.IdsEntry")
241 proto.RegisterMapType((map[string]*github_com_gogo_protobuf_test_custom.Uint128)(nil), "proto2.maps.CustomMap.Nullable128sEntry")
242 proto.RegisterMapType((map[string]*github_com_gogo_protobuf_test.Uuid)(nil), "proto2.maps.CustomMap.NullableIdsEntry")
243 proto.RegisterMapType((map[string]github_com_gogo_protobuf_test_custom.Uint128)(nil), "proto2.maps.CustomMap.Uint128sEntry")
244 proto.RegisterType((*AllMaps)(nil), "proto2.maps.AllMaps")
245 proto.RegisterMapType((map[bool]bool)(nil), "proto2.maps.AllMaps.BoolMapEntry")
246 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMaps.Fixed32MapEntry")
247 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMaps.Fixed64MapEntry")
248 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMaps.Int32MapEntry")
249 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMaps.Int64MapEntry")
250 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMaps.Sfixed32MapEntry")
251 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMaps.Sfixed64MapEntry")
252 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMaps.Sint32MapEntry")
253 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMaps.Sint64MapEntry")
254 proto.RegisterMapType((map[string]string)(nil), "proto2.maps.AllMaps.StringMapEntry")
255 proto.RegisterMapType((map[string][]byte)(nil), "proto2.maps.AllMaps.StringToBytesMapEntry")
256 proto.RegisterMapType((map[string]float64)(nil), "proto2.maps.AllMaps.StringToDoubleMapEntry")
257 proto.RegisterMapType((map[string]MapEnum)(nil), "proto2.maps.AllMaps.StringToEnumMapEntry")
258 proto.RegisterMapType((map[string]float32)(nil), "proto2.maps.AllMaps.StringToFloatMapEntry")
259 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "proto2.maps.AllMaps.StringToMsgMapEntry")
260 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMaps.Uint32MapEntry")
261 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMaps.Uint64MapEntry")
262 proto.RegisterType((*AllMapsOrdered)(nil), "proto2.maps.AllMapsOrdered")
263 proto.RegisterMapType((map[bool]bool)(nil), "proto2.maps.AllMapsOrdered.BoolMapEntry")
264 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMapsOrdered.Fixed32MapEntry")
265 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMapsOrdered.Fixed64MapEntry")
266 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMapsOrdered.Int32MapEntry")
267 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMapsOrdered.Int64MapEntry")
268 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMapsOrdered.Sfixed32MapEntry")
269 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMapsOrdered.Sfixed64MapEntry")
270 proto.RegisterMapType((map[int32]int32)(nil), "proto2.maps.AllMapsOrdered.Sint32MapEntry")
271 proto.RegisterMapType((map[int64]int64)(nil), "proto2.maps.AllMapsOrdered.Sint64MapEntry")
272 proto.RegisterMapType((map[string]string)(nil), "proto2.maps.AllMapsOrdered.StringMapEntry")
273 proto.RegisterMapType((map[string][]byte)(nil), "proto2.maps.AllMapsOrdered.StringToBytesMapEntry")
274 proto.RegisterMapType((map[string]float64)(nil), "proto2.maps.AllMapsOrdered.StringToDoubleMapEntry")
275 proto.RegisterMapType((map[string]MapEnum)(nil), "proto2.maps.AllMapsOrdered.StringToEnumMapEntry")
276 proto.RegisterMapType((map[string]float32)(nil), "proto2.maps.AllMapsOrdered.StringToFloatMapEntry")
277 proto.RegisterMapType((map[string]*FloatingPoint)(nil), "proto2.maps.AllMapsOrdered.StringToMsgMapEntry")
278 proto.RegisterMapType((map[uint32]uint32)(nil), "proto2.maps.AllMapsOrdered.Uint32MapEntry")
279 proto.RegisterMapType((map[uint64]uint64)(nil), "proto2.maps.AllMapsOrdered.Uint64MapEntry")
280 }
281
282 func init() {
283 proto.RegisterFile("combos/unmarshaler/mapsproto2.proto", fileDescriptor_6f53681484260870)
284 }
285
286 var fileDescriptor_6f53681484260870 = []byte{
287
288 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x97, 0xcd, 0x6f, 0x1a, 0x47,
289 0x18, 0xc6, 0x19, 0xb0, 0x0d, 0x0c, 0xdf, 0x93, 0xb4, 0x42, 0x48, 0x1d, 0x1c, 0xd2, 0x0f, 0x42,
290 0x52, 0xb0, 0x69, 0x14, 0x59, 0x4e, 0x9b, 0xca, 0xd8, 0x4e, 0xb1, 0x52, 0xdc, 0x08, 0x9a, 0x7e,
291 0x49, 0x96, 0x0a, 0x66, 0x21, 0xa8, 0xc0, 0x52, 0x76, 0x37, 0xaa, 0x2f, 0x55, 0xfe, 0x8c, 0x5e,
292 0x7b, 0xeb, 0xb1, 0xc7, 0x1e, 0x7b, 0xb4, 0xd4, 0x4b, 0x8e, 0x51, 0x54, 0x59, 0x61, 0x7b, 0xc9,
293 0x31, 0xc7, 0x1c, 0xab, 0x9d, 0xdd, 0x85, 0xd9, 0xdd, 0x77, 0x77, 0xa1, 0xa7, 0x1e, 0x7c, 0xc2,
294 0xb3, 0xbc, 0xcf, 0xef, 0x79, 0x77, 0x77, 0xe6, 0xe5, 0x31, 0xbe, 0x7e, 0x2a, 0x8e, 0x3a, 0xa2,
295 0x54, 0x51, 0xc6, 0xa3, 0xf6, 0x54, 0x7a, 0xdc, 0x1e, 0x0a, 0xd3, 0xca, 0xa8, 0x3d, 0x91, 0x26,
296 0x53, 0x51, 0x16, 0xab, 0x65, 0xf6, 0x41, 0x62, 0xc6, 0x4a, 0xfb, 0x22, 0xf7, 0x61, 0x7f, 0x20,
297 0x3f, 0x56, 0x3a, 0xe5, 0x53, 0x71, 0x54, 0xe9, 0x8b, 0x7d, 0xb1, 0xc2, 0xbe, 0xec, 0x28, 0x3d,
298 0xb6, 0x62, 0x0b, 0xf6, 0x97, 0xae, 0x2d, 0xbc, 0x83, 0x13, 0xf7, 0x87, 0x62, 0x5b, 0x1e, 0x8c,
299 0xfb, 0x0f, 0xc5, 0xc1, 0x58, 0x26, 0x71, 0x8c, 0x7a, 0x59, 0xb4, 0x89, 0x8a, 0xa8, 0x89, 0x7a,
300 0x85, 0xbf, 0xd6, 0x71, 0x74, 0x5f, 0x91, 0x64, 0x71, 0xd4, 0x68, 0x4f, 0xc8, 0xcf, 0x38, 0x7e,
301 0xac, 0x0c, 0x87, 0xed, 0xce, 0x50, 0xd8, 0xae, 0xee, 0x48, 0x59, 0xb4, 0x19, 0x2a, 0xc6, 0xaa,
302 0xc5, 0x32, 0xe7, 0x5f, 0x9e, 0x57, 0x97, 0xf9, 0xd2, 0xc3, 0xb1, 0x3c, 0x3d, 0xab, 0x6d, 0xbd,
303 0xb8, 0xc8, 0xdf, 0x72, 0xed, 0x4f, 0x16, 0x24, 0xb9, 0x72, 0xca, 0xe4, 0xe5, 0x47, 0x83, 0xb1,
304 0xbc, 0x5d, 0xdd, 0x69, 0x5a, 0xfc, 0xc8, 0x13, 0x1c, 0x31, 0xbe, 0x90, 0xb2, 0x41, 0xe6, 0xfd,
305 0xae, 0x8b, 0xb7, 0x59, 0xa6, 0xfb, 0xde, 0x3e, 0xbf, 0xc8, 0x07, 0x56, 0xf6, 0x9e, 0x7b, 0x91,
306 0x1f, 0x71, 0xcc, 0xec, 0xe3, 0xa8, 0x2b, 0x65, 0x43, 0xcc, 0xfa, 0x03, 0x9f, 0xdb, 0x3e, 0xea,
307 0x1a, 0xee, 0xef, 0xbf, 0xb8, 0xc8, 0x17, 0x3c, 0x9d, 0xcb, 0x8f, 0x94, 0x41, 0xb7, 0xc9, 0x7b,
308 0x90, 0x13, 0x1c, 0xd2, 0xac, 0xd6, 0x98, 0x55, 0xde, 0xc5, 0x6a, 0x6e, 0x51, 0x32, 0x6e, 0x70,
309 0x19, 0x1b, 0x8d, 0x9b, 0xfb, 0x14, 0x67, 0x1c, 0xaf, 0x87, 0xa4, 0x71, 0xe8, 0x07, 0xe1, 0x8c,
310 0xbd, 0xfc, 0x68, 0x53, 0xfb, 0x93, 0x5c, 0xc5, 0xeb, 0x4f, 0xda, 0x43, 0x45, 0xc8, 0x06, 0x37,
311 0x51, 0x31, 0xde, 0xd4, 0x17, 0xbb, 0xc1, 0x1d, 0x94, 0xbb, 0x8b, 0x13, 0x96, 0x67, 0xbc, 0x92,
312 0xf8, 0x1e, 0x4e, 0xdb, 0x9f, 0xd2, 0x4a, 0xfa, 0x3b, 0x38, 0xf2, 0x5f, 0x74, 0x85, 0xe7, 0x04,
313 0x87, 0xf7, 0x86, 0xc3, 0x46, 0x7b, 0x22, 0x91, 0x6f, 0x71, 0xa6, 0x25, 0x4f, 0x07, 0xe3, 0xfe,
314 0x97, 0xe2, 0x81, 0xa8, 0x74, 0x86, 0x42, 0xa3, 0x3d, 0x31, 0x36, 0xf4, 0x4d, 0xcb, 0xe3, 0x36,
315 0x04, 0x65, 0x47, 0x35, 0xf3, 0x6f, 0x3a, 0x29, 0xe4, 0x2b, 0x9c, 0x36, 0x2f, 0xb2, 0xb3, 0xa5,
316 0x91, 0xf5, 0xed, 0x5a, 0xf2, 0x24, 0x9b, 0xc5, 0x3a, 0xd8, 0xc1, 0x20, 0xf7, 0x70, 0xe4, 0x68,
317 0x2c, 0x7f, 0x54, 0xd5, 0x78, 0xfa, 0x1e, 0x2c, 0x80, 0x3c, 0xb3, 0x48, 0xe7, 0xcc, 0x35, 0x86,
318 0xfe, 0xce, 0x6d, 0x4d, 0xbf, 0xe6, 0xad, 0x67, 0x45, 0x0b, 0x3d, 0x5b, 0x92, 0x3d, 0x1c, 0xd5,
319 0xde, 0xb9, 0xde, 0xc0, 0x3a, 0x03, 0x5c, 0x07, 0x01, 0xf3, 0x2a, 0x9d, 0xb0, 0x50, 0x99, 0x08,
320 0xbd, 0x87, 0x0d, 0x1f, 0x04, 0xd7, 0xc4, 0x42, 0xa5, 0x21, 0x5a, 0xf3, 0x2e, 0xc2, 0x1e, 0x88,
321 0x96, 0xad, 0x8b, 0x16, 0xdf, 0x45, 0x6b, 0xde, 0x45, 0xc4, 0x07, 0xc1, 0x77, 0x31, 0x5f, 0x93,
322 0x03, 0x8c, 0xef, 0x0f, 0x7e, 0x12, 0xba, 0x7a, 0x1b, 0x51, 0x60, 0x18, 0x99, 0x8c, 0x45, 0x99,
323 0x0e, 0xe1, 0x74, 0xe4, 0x33, 0x1c, 0x6b, 0xf5, 0x16, 0x18, 0xcc, 0x30, 0xef, 0xc1, 0xad, 0xf4,
324 0x6c, 0x1c, 0x5e, 0x39, 0x6f, 0x47, 0xbf, 0xa5, 0x98, 0x5f, 0x3b, 0xdc, 0x3d, 0x71, 0xba, 0x45,
325 0x3b, 0x3a, 0x26, 0xee, 0xdb, 0x0e, 0xc7, 0xe1, 0x95, 0xe4, 0x2e, 0x0e, 0xd7, 0x44, 0x51, 0xab,
326 0xcc, 0x26, 0x18, 0xe4, 0x1a, 0x08, 0x31, 0x6a, 0x74, 0x80, 0xa9, 0x60, 0x6f, 0x87, 0x6d, 0x7d,
327 0x4d, 0x9e, 0xf4, 0x7a, 0x3b, 0x66, 0x95, 0xf9, 0x76, 0xcc, 0x35, 0x7f, 0x02, 0x6b, 0x67, 0xb2,
328 0x20, 0x69, 0xa4, 0xd4, 0x12, 0x27, 0xd0, 0x2c, 0xb6, 0x9d, 0x40, 0xf3, 0x32, 0x69, 0xe1, 0x94,
329 0x79, 0xed, 0x70, 0xac, 0x68, 0x33, 0x38, 0x9b, 0x66, 0xd8, 0x1b, 0x9e, 0x58, 0xa3, 0x56, 0xa7,
330 0xda, 0x09, 0xe4, 0x21, 0x4e, 0x9a, 0x97, 0x1a, 0x12, 0xbb, 0xe9, 0x0c, 0xf0, 0xbb, 0x6a, 0x67,
331 0xea, 0xa5, 0x3a, 0xd2, 0xa6, 0xcf, 0x1d, 0xe0, 0xb7, 0xe1, 0x69, 0xe5, 0x37, 0x2d, 0x11, 0x3f,
332 0x65, 0xf7, 0xf1, 0x5b, 0xe0, 0x64, 0xf2, 0x83, 0x04, 0x6d, 0xbf, 0x13, 0x96, 0x71, 0xc4, 0x8b,
333 0xd7, 0x01, 0xf1, 0xba, 0x53, 0xbc, 0xd8, 0x64, 0xbc, 0x38, 0x04, 0x88, 0x43, 0xbc, 0xf8, 0x63,
334 0x9c, 0xb4, 0xce, 0x21, 0x5e, 0x9d, 0x00, 0xd4, 0x09, 0x40, 0x0d, 0x7b, 0xaf, 0x01, 0xea, 0x35,
335 0x9b, 0xba, 0xe5, 0xea, 0x9d, 0x01, 0xd4, 0x19, 0x40, 0x0d, 0x7b, 0x13, 0x40, 0x4d, 0x78, 0xf5,
336 0x27, 0x38, 0x65, 0x1b, 0x39, 0xbc, 0x3c, 0x0c, 0xc8, 0xc3, 0xb6, 0xdf, 0x66, 0xfb, 0xa8, 0xe1,
337 0xf5, 0x29, 0x40, 0x9f, 0x82, 0xec, 0xe1, 0xee, 0x37, 0x00, 0xf9, 0x06, 0x68, 0x0f, 0xeb, 0xd3,
338 0x80, 0x3e, 0xcd, 0xeb, 0x77, 0x71, 0x9c, 0x9f, 0x2a, 0xbc, 0x36, 0x02, 0x68, 0x23, 0xf6, 0xe7,
339 0x6e, 0x19, 0x29, 0x7e, 0x3b, 0x3d, 0xea, 0x72, 0x5c, 0x2c, 0x63, 0x64, 0xa5, 0x64, 0xf3, 0x0d,
340 0xbe, 0x0a, 0x0d, 0x0d, 0x80, 0x51, 0xe2, 0x19, 0xc9, 0xea, 0x55, 0xcb, 0xb0, 0x60, 0x3a, 0x65,
341 0xc4, 0x93, 0x4f, 0xf0, 0x15, 0x60, 0x74, 0x00, 0xe0, 0x2d, 0x1e, 0x1c, 0xab, 0xe6, 0x2c, 0x60,
342 0xcb, 0xff, 0x0a, 0x7c, 0xb4, 0xfa, 0xfb, 0x0a, 0x4e, 0x1a, 0x23, 0xea, 0x8b, 0x69, 0x57, 0x98,
343 0x0a, 0x5d, 0xf2, 0xbd, 0x7b, 0xc2, 0xaa, 0x42, 0xa3, 0xcd, 0xd0, 0xad, 0x10, 0xb4, 0x4e, 0x5c,
344 0x83, 0xd6, 0xf6, 0x32, 0x06, 0x7e, 0x79, 0xeb, 0xd0, 0x91, 0xb7, 0x6e, 0x78, 0x61, 0xdd, 0x62,
345 0xd7, 0xa1, 0x23, 0x76, 0xf9, 0x61, 0xc0, 0xf4, 0x55, 0x77, 0xa6, 0xaf, 0x92, 0x17, 0xc7, 0x3d,
346 0x84, 0xd5, 0x9d, 0x21, 0xcc, 0x97, 0x04, 0x67, 0xb1, 0xba, 0x33, 0x8b, 0x79, 0x92, 0xdc, 0x23,
347 0x59, 0xdd, 0x19, 0xc9, 0x7c, 0x49, 0x70, 0x32, 0x7b, 0x00, 0x24, 0xb3, 0x9b, 0x5e, 0x28, 0xaf,
348 0x80, 0x76, 0x0c, 0x05, 0xb4, 0x5b, 0x9e, 0x8d, 0x79, 0xe6, 0xb4, 0x07, 0x40, 0x4e, 0xf3, 0x6f,
349 0xce, 0x25, 0xae, 0x1d, 0x43, 0x71, 0x6d, 0x89, 0xe6, 0xdc, 0x52, 0x5b, 0xcd, 0x9e, 0xda, 0x8a,
350 0x5e, 0x2c, 0x38, 0xbc, 0xd5, 0x9d, 0xe1, 0xad, 0xe4, 0x7f, 0x16, 0xa1, 0x0c, 0x77, 0xe2, 0x9a,
351 0xe1, 0x96, 0x3a, 0xdc, 0x7e, 0x51, 0xee, 0x3b, 0xb7, 0x28, 0xb7, 0xb5, 0x0c, 0xdd, 0x3b, 0xd1,
352 0x7d, 0xed, 0x92, 0xe8, 0x2a, 0xcb, 0xa0, 0x2f, 0x83, 0xdd, 0x65, 0xb0, 0xbb, 0x0c, 0x76, 0x97,
353 0xc1, 0xee, 0xff, 0x11, 0xec, 0x76, 0xd7, 0x7e, 0xf9, 0x35, 0x8f, 0x4a, 0xd7, 0x70, 0xd8, 0xb0,
354 0x26, 0x1b, 0x38, 0xd8, 0xd8, 0x4b, 0x07, 0xd8, 0x67, 0x2d, 0x8d, 0xd8, 0xe7, 0x7e, 0x3a, 0x58,
355 0xfb, 0xfc, 0x7c, 0x46, 0x03, 0xcf, 0x66, 0x34, 0xf0, 0x7c, 0x46, 0x03, 0x2f, 0x67, 0x14, 0xbd,
356 0x9a, 0x51, 0xf4, 0x7a, 0x46, 0xd1, 0x9b, 0x19, 0x45, 0x4f, 0x55, 0x8a, 0x7e, 0x53, 0x29, 0xfa,
357 0x5d, 0xa5, 0xe8, 0x0f, 0x95, 0xa2, 0x3f, 0x55, 0x8a, 0xce, 0x55, 0x1a, 0x78, 0xa6, 0x52, 0xf4,
358 0x52, 0xa5, 0xe8, 0x95, 0x4a, 0x03, 0xaf, 0x55, 0x8a, 0xde, 0xa8, 0x34, 0xf0, 0xf4, 0x1f, 0x1a,
359 0xf8, 0x37, 0x00, 0x00, 0xff, 0xff, 0x1b, 0xc4, 0xd5, 0x8e, 0xf9, 0x16, 0x00, 0x00,
360 }
361
362 func (this *FloatingPoint) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
363 return Mapsproto2Description()
364 }
365 func (this *CustomMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
366 return Mapsproto2Description()
367 }
368 func (this *AllMaps) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
369 return Mapsproto2Description()
370 }
371 func (this *AllMapsOrdered) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
372 return Mapsproto2Description()
373 }
374 func Mapsproto2Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
375 d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
376 var gzipped = []byte{
377
378 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x5b, 0x6c, 0x23, 0xd7,
379 0x79, 0xd6, 0xf0, 0x22, 0x91, 0x3f, 0x29, 0x6a, 0x34, 0x92, 0xd7, 0xb4, 0x12, 0x6b, 0x77, 0xe5,
380 0x9b, 0xbc, 0x6b, 0x4b, 0xb6, 0xbc, 0xbb, 0x5e, 0x73, 0x63, 0xbb, 0x94, 0xc4, 0xd5, 0xca, 0xd6,
381 0x2d, 0x43, 0xc9, 0xb7, 0xc0, 0x98, 0x8e, 0x86, 0x47, 0xd4, 0x78, 0xc9, 0x19, 0x7a, 0x66, 0xb8,
382 0x6b, 0x19, 0x45, 0xb1, 0x85, 0x7b, 0x41, 0xd0, 0xfb, 0x05, 0xa8, 0xe3, 0x3a, 0x6e, 0x9d, 0xa2,
383 0x71, 0x9a, 0xde, 0x92, 0x5e, 0xd2, 0x24, 0x7d, 0xc9, 0x4b, 0x5a, 0x03, 0x05, 0x8a, 0xe4, 0x2d,
384 0x08, 0x02, 0xc3, 0xab, 0x18, 0xa8, 0xdb, 0xba, 0xad, 0xdb, 0xfa, 0xc1, 0x85, 0x5f, 0x8a, 0x73,
385 0x1b, 0x9e, 0x19, 0x0e, 0x39, 0x94, 0x01, 0x3b, 0x7d, 0xf0, 0xd3, 0x6a, 0xce, 0xf9, 0xbf, 0xef,
386 0xfc, 0xf3, 0x9f, 0xff, 0xfc, 0xe7, 0x3b, 0x67, 0xb8, 0xf0, 0x7a, 0x09, 0x4e, 0xd4, 0x6d, 0xbb,
387 0xde, 0x40, 0xf3, 0x2d, 0xc7, 0xf6, 0xec, 0xdd, 0xf6, 0xde, 0x7c, 0x0d, 0xb9, 0x86, 0x63, 0xb6,
388 0x3c, 0xdb, 0x99, 0x23, 0x6d, 0xca, 0x18, 0xb5, 0x98, 0xe3, 0x16, 0x33, 0xeb, 0x30, 0x7e, 0xd1,
389 0x6c, 0xa0, 0x65, 0xdf, 0xb0, 0x8a, 0x3c, 0xe5, 0x3c, 0xa4, 0xf6, 0xcc, 0x06, 0x2a, 0x4a, 0x27,
390 0x92, 0xb3, 0xb9, 0x85, 0x5b, 0xe7, 0x42, 0xa0, 0xb9, 0x20, 0x62, 0x0b, 0x37, 0xab, 0x04, 0x31,
391 0xf3, 0x56, 0x0a, 0x26, 0x22, 0x7a, 0x15, 0x05, 0x52, 0x96, 0xde, 0xc4, 0x8c, 0xd2, 0x6c, 0x56,
392 0x25, 0x7f, 0x2b, 0x45, 0x18, 0x69, 0xe9, 0xc6, 0x65, 0xbd, 0x8e, 0x8a, 0x09, 0xd2, 0xcc, 0x1f,
393 0x95, 0x69, 0x80, 0x1a, 0x6a, 0x21, 0xab, 0x86, 0x2c, 0xe3, 0xa0, 0x98, 0x3c, 0x91, 0x9c, 0xcd,
394 0xaa, 0x42, 0x8b, 0x72, 0x1a, 0xc6, 0x5b, 0xed, 0xdd, 0x86, 0x69, 0x68, 0x82, 0x19, 0x9c, 0x48,
395 0xce, 0xa6, 0x55, 0x99, 0x76, 0x2c, 0x77, 0x8c, 0xef, 0x80, 0xb1, 0xab, 0x48, 0xbf, 0x2c, 0x9a,
396 0xe6, 0x88, 0x69, 0x01, 0x37, 0x0b, 0x86, 0x4b, 0x90, 0x6f, 0x22, 0xd7, 0xd5, 0xeb, 0x48, 0xf3,
397 0x0e, 0x5a, 0xa8, 0x98, 0x22, 0x6f, 0x7f, 0xa2, 0xeb, 0xed, 0xc3, 0x6f, 0x9e, 0x63, 0xa8, 0xed,
398 0x83, 0x16, 0x52, 0xca, 0x90, 0x45, 0x56, 0xbb, 0x49, 0x19, 0xd2, 0x3d, 0xe2, 0x57, 0xb1, 0xda,
399 0xcd, 0x30, 0x4b, 0x06, 0xc3, 0x18, 0xc5, 0x88, 0x8b, 0x9c, 0x2b, 0xa6, 0x81, 0x8a, 0xc3, 0x84,
400 0xe0, 0x8e, 0x2e, 0x82, 0x2a, 0xed, 0x0f, 0x73, 0x70, 0x9c, 0xb2, 0x04, 0x59, 0xf4, 0x9c, 0x87,
401 0x2c, 0xd7, 0xb4, 0xad, 0xe2, 0x08, 0x21, 0xb9, 0x2d, 0x62, 0x16, 0x51, 0xa3, 0x16, 0xa6, 0xe8,
402 0xe0, 0x94, 0x73, 0x30, 0x62, 0xb7, 0x3c, 0xd3, 0xb6, 0xdc, 0x62, 0xe6, 0x84, 0x34, 0x9b, 0x5b,
403 0xf8, 0x74, 0x64, 0x22, 0x6c, 0x52, 0x1b, 0x95, 0x1b, 0x2b, 0xab, 0x20, 0xbb, 0x76, 0xdb, 0x31,
404 0x90, 0x66, 0xd8, 0x35, 0xa4, 0x99, 0xd6, 0x9e, 0x5d, 0xcc, 0x12, 0x82, 0xe3, 0xdd, 0x2f, 0x42,
405 0x0c, 0x97, 0xec, 0x1a, 0x5a, 0xb5, 0xf6, 0x6c, 0xb5, 0xe0, 0x06, 0x9e, 0x95, 0x63, 0x30, 0xec,
406 0x1e, 0x58, 0x9e, 0xfe, 0x5c, 0x31, 0x4f, 0x32, 0x84, 0x3d, 0xcd, 0x7c, 0x6b, 0x18, 0xc6, 0x06,
407 0x49, 0xb1, 0x0b, 0x90, 0xde, 0xc3, 0x6f, 0x59, 0x4c, 0x1c, 0x25, 0x06, 0x14, 0x13, 0x0c, 0xe2,
408 0xf0, 0x87, 0x0c, 0x62, 0x19, 0x72, 0x16, 0x72, 0x3d, 0x54, 0xa3, 0x19, 0x91, 0x1c, 0x30, 0xa7,
409 0x80, 0x82, 0xba, 0x53, 0x2a, 0xf5, 0xa1, 0x52, 0xea, 0x09, 0x18, 0xf3, 0x5d, 0xd2, 0x1c, 0xdd,
410 0xaa, 0xf3, 0xdc, 0x9c, 0x8f, 0xf3, 0x64, 0xae, 0xc2, 0x71, 0x2a, 0x86, 0xa9, 0x05, 0x14, 0x78,
411 0x56, 0x96, 0x01, 0x6c, 0x0b, 0xd9, 0x7b, 0x5a, 0x0d, 0x19, 0x8d, 0x62, 0xa6, 0x47, 0x94, 0x36,
412 0xb1, 0x49, 0x57, 0x94, 0x6c, 0xda, 0x6a, 0x34, 0x94, 0x07, 0x3a, 0xa9, 0x36, 0xd2, 0x23, 0x53,
413 0xd6, 0xe9, 0x22, 0xeb, 0xca, 0xb6, 0x1d, 0x28, 0x38, 0x08, 0xe7, 0x3d, 0xaa, 0xb1, 0x37, 0xcb,
414 0x12, 0x27, 0xe6, 0x62, 0xdf, 0x4c, 0x65, 0x30, 0xfa, 0x62, 0xa3, 0x8e, 0xf8, 0xa8, 0xdc, 0x02,
415 0x7e, 0x83, 0x46, 0xd2, 0x0a, 0x48, 0x15, 0xca, 0xf3, 0xc6, 0x0d, 0xbd, 0x89, 0xa6, 0x9e, 0x87,
416 0x42, 0x30, 0x3c, 0xca, 0x24, 0xa4, 0x5d, 0x4f, 0x77, 0x3c, 0x92, 0x85, 0x69, 0x95, 0x3e, 0x28,
417 0x32, 0x24, 0x91, 0x55, 0x23, 0x55, 0x2e, 0xad, 0xe2, 0x3f, 0x95, 0x9f, 0xea, 0xbc, 0x70, 0x92,
418 0xbc, 0xf0, 0xed, 0xdd, 0x33, 0x1a, 0x60, 0x0e, 0xbf, 0xf7, 0xd4, 0xfd, 0x30, 0x1a, 0x78, 0x81,
419 0x41, 0x87, 0x9e, 0xf9, 0x19, 0xb8, 0x21, 0x92, 0x5a, 0x79, 0x02, 0x26, 0xdb, 0x96, 0x69, 0x79,
420 0xc8, 0x69, 0x39, 0x08, 0x67, 0x2c, 0x1d, 0xaa, 0xf8, 0xcf, 0x23, 0x3d, 0x72, 0x6e, 0x47, 0xb4,
421 0xa6, 0x2c, 0xea, 0x44, 0xbb, 0xbb, 0xf1, 0x54, 0x36, 0xf3, 0xf6, 0x88, 0x7c, 0xed, 0xda, 0xb5,
422 0x6b, 0x89, 0x99, 0x17, 0x87, 0x61, 0x32, 0x6a, 0xcd, 0x44, 0x2e, 0xdf, 0x63, 0x30, 0x6c, 0xb5,
423 0x9b, 0xbb, 0xc8, 0x21, 0x41, 0x4a, 0xab, 0xec, 0x49, 0x29, 0x43, 0xba, 0xa1, 0xef, 0xa2, 0x46,
424 0x31, 0x75, 0x42, 0x9a, 0x2d, 0x2c, 0x9c, 0x1e, 0x68, 0x55, 0xce, 0xad, 0x61, 0x88, 0x4a, 0x91,
425 0xca, 0x43, 0x90, 0x62, 0x25, 0x1a, 0x33, 0x9c, 0x1a, 0x8c, 0x01, 0xaf, 0x25, 0x95, 0xe0, 0x94,
426 0x4f, 0x41, 0x16, 0xff, 0x4b, 0x73, 0x63, 0x98, 0xf8, 0x9c, 0xc1, 0x0d, 0x38, 0x2f, 0x94, 0x29,
427 0xc8, 0x90, 0x65, 0x52, 0x43, 0x7c, 0x6b, 0xf3, 0x9f, 0x71, 0x62, 0xd5, 0xd0, 0x9e, 0xde, 0x6e,
428 0x78, 0xda, 0x15, 0xbd, 0xd1, 0x46, 0x24, 0xe1, 0xb3, 0x6a, 0x9e, 0x35, 0x3e, 0x86, 0xdb, 0x94,
429 0xe3, 0x90, 0xa3, 0xab, 0xca, 0xb4, 0x6a, 0xe8, 0x39, 0x52, 0x3d, 0xd3, 0x2a, 0x5d, 0x68, 0xab,
430 0xb8, 0x05, 0x0f, 0xff, 0x8c, 0x6b, 0x5b, 0x3c, 0x35, 0xc9, 0x10, 0xb8, 0x81, 0x0c, 0x7f, 0x7f,
431 0xb8, 0x70, 0xdf, 0x1c, 0xfd, 0x7a, 0xe1, 0x9c, 0x9a, 0xf9, 0x46, 0x02, 0x52, 0xa4, 0x5e, 0x8c,
432 0x41, 0x6e, 0xfb, 0xc9, 0xad, 0x8a, 0xb6, 0xbc, 0xb9, 0xb3, 0xb8, 0x56, 0x91, 0x25, 0xa5, 0x00,
433 0x40, 0x1a, 0x2e, 0xae, 0x6d, 0x96, 0xb7, 0xe5, 0x84, 0xff, 0xbc, 0xba, 0xb1, 0x7d, 0xee, 0x8c,
434 0x9c, 0xf4, 0x01, 0x3b, 0xb4, 0x21, 0x25, 0x1a, 0xdc, 0xb7, 0x20, 0xa7, 0x15, 0x19, 0xf2, 0x94,
435 0x60, 0xf5, 0x89, 0xca, 0xf2, 0xb9, 0x33, 0xf2, 0x70, 0xb0, 0xe5, 0xbe, 0x05, 0x79, 0x44, 0x19,
436 0x85, 0x2c, 0x69, 0x59, 0xdc, 0xdc, 0x5c, 0x93, 0x33, 0x3e, 0x67, 0x75, 0x5b, 0x5d, 0xdd, 0x58,
437 0x91, 0xb3, 0x3e, 0xe7, 0x8a, 0xba, 0xb9, 0xb3, 0x25, 0x83, 0xcf, 0xb0, 0x5e, 0xa9, 0x56, 0xcb,
438 0x2b, 0x15, 0x39, 0xe7, 0x5b, 0x2c, 0x3e, 0xb9, 0x5d, 0xa9, 0xca, 0xf9, 0x80, 0x5b, 0xf7, 0x2d,
439 0xc8, 0xa3, 0xfe, 0x10, 0x95, 0x8d, 0x9d, 0x75, 0xb9, 0xa0, 0x8c, 0xc3, 0x28, 0x1d, 0x82, 0x3b,
440 0x31, 0x16, 0x6a, 0x3a, 0x77, 0x46, 0x96, 0x3b, 0x8e, 0x50, 0x96, 0xf1, 0x40, 0xc3, 0xb9, 0x33,
441 0xb2, 0x32, 0xb3, 0x04, 0x69, 0x92, 0x5d, 0x8a, 0x02, 0x85, 0xb5, 0xf2, 0x62, 0x65, 0x4d, 0xdb,
442 0xdc, 0xda, 0x5e, 0xdd, 0xdc, 0x28, 0xaf, 0xc9, 0x52, 0xa7, 0x4d, 0xad, 0x7c, 0x76, 0x67, 0x55,
443 0xad, 0x2c, 0xcb, 0x09, 0xb1, 0x6d, 0xab, 0x52, 0xde, 0xae, 0x2c, 0xcb, 0xc9, 0x19, 0x03, 0x26,
444 0xa3, 0xea, 0x64, 0xe4, 0xca, 0x10, 0xa6, 0x38, 0xd1, 0x63, 0x8a, 0x09, 0x57, 0xd7, 0x14, 0xff,
445 0x38, 0x01, 0x13, 0x11, 0x7b, 0x45, 0xe4, 0x20, 0x0f, 0x43, 0x9a, 0xa6, 0x28, 0xdd, 0x3d, 0xef,
446 0x8c, 0xdc, 0x74, 0x48, 0xc2, 0x76, 0xed, 0xa0, 0x04, 0x27, 0x2a, 0x88, 0x64, 0x0f, 0x05, 0x81,
447 0x29, 0xba, 0x6a, 0xfa, 0xd3, 0x5d, 0x35, 0x9d, 0x6e, 0x7b, 0xe7, 0x06, 0xd9, 0xf6, 0x48, 0xdb,
448 0xd1, 0x6a, 0x7b, 0x3a, 0xa2, 0xb6, 0x5f, 0x80, 0xf1, 0x2e, 0xa2, 0x81, 0x6b, 0xec, 0x0b, 0x12,
449 0x14, 0x7b, 0x05, 0x27, 0xa6, 0xd2, 0x25, 0x02, 0x95, 0xee, 0x42, 0x38, 0x82, 0x27, 0x7b, 0x4f,
450 0x42, 0xd7, 0x5c, 0xbf, 0x26, 0xc1, 0xb1, 0x68, 0xa5, 0x18, 0xe9, 0xc3, 0x43, 0x30, 0xdc, 0x44,
451 0xde, 0xbe, 0xcd, 0xd5, 0xd2, 0xed, 0x11, 0x7b, 0x30, 0xee, 0x0e, 0x4f, 0x36, 0x43, 0x89, 0x9b,
452 0x78, 0xb2, 0x97, 0xdc, 0xa3, 0xde, 0x74, 0x79, 0xfa, 0xf9, 0x04, 0xdc, 0x10, 0x49, 0x1e, 0xe9,
453 0xe8, 0xcd, 0x00, 0xa6, 0xd5, 0x6a, 0x7b, 0x54, 0x11, 0xd1, 0x02, 0x9b, 0x25, 0x2d, 0xa4, 0x78,
454 0xe1, 0xe2, 0xd9, 0xf6, 0xfc, 0xfe, 0x24, 0xe9, 0x07, 0xda, 0x44, 0x0c, 0xce, 0x77, 0x1c, 0x4d,
455 0x11, 0x47, 0xa7, 0x7b, 0xbc, 0x69, 0x57, 0x62, 0xde, 0x03, 0xb2, 0xd1, 0x30, 0x91, 0xe5, 0x69,
456 0xae, 0xe7, 0x20, 0xbd, 0x69, 0x5a, 0x75, 0xb2, 0x83, 0x64, 0x4a, 0xe9, 0x3d, 0xbd, 0xe1, 0x22,
457 0x75, 0x8c, 0x76, 0x57, 0x79, 0x2f, 0x46, 0x90, 0x04, 0x72, 0x04, 0xc4, 0x70, 0x00, 0x41, 0xbb,
458 0x7d, 0xc4, 0xcc, 0xaf, 0x64, 0x21, 0x27, 0xe8, 0x6a, 0xe5, 0x24, 0xe4, 0x9f, 0xd1, 0xaf, 0xe8,
459 0x1a, 0x3f, 0x2b, 0xd1, 0x48, 0xe4, 0x70, 0xdb, 0x16, 0x3b, 0x2f, 0xdd, 0x03, 0x93, 0xc4, 0xc4,
460 0x6e, 0x7b, 0xc8, 0xd1, 0x8c, 0x86, 0xee, 0xba, 0x24, 0x68, 0x19, 0x62, 0xaa, 0xe0, 0xbe, 0x4d,
461 0xdc, 0xb5, 0xc4, 0x7b, 0x94, 0xb3, 0x30, 0x41, 0x10, 0xcd, 0x76, 0xc3, 0x33, 0x5b, 0x0d, 0xa4,
462 0xe1, 0xd3, 0x9b, 0x4b, 0x76, 0x12, 0xdf, 0xb3, 0x71, 0x6c, 0xb1, 0xce, 0x0c, 0xb0, 0x47, 0xae,
463 0xb2, 0x0c, 0x37, 0x13, 0x58, 0x1d, 0x59, 0xc8, 0xd1, 0x3d, 0xa4, 0xa1, 0x67, 0xdb, 0x7a, 0xc3,
464 0xd5, 0x74, 0xab, 0xa6, 0xed, 0xeb, 0xee, 0x7e, 0x71, 0x12, 0x13, 0x2c, 0x26, 0x8a, 0x92, 0x7a,
465 0x13, 0x36, 0x5c, 0x61, 0x76, 0x15, 0x62, 0x56, 0xb6, 0x6a, 0x97, 0x74, 0x77, 0x5f, 0x29, 0xc1,
466 0x31, 0xc2, 0xe2, 0x7a, 0x8e, 0x69, 0xd5, 0x35, 0x63, 0x1f, 0x19, 0x97, 0xb5, 0xb6, 0xb7, 0x77,
467 0xbe, 0xf8, 0x29, 0x71, 0x7c, 0xe2, 0x61, 0x95, 0xd8, 0x2c, 0x61, 0x93, 0x1d, 0x6f, 0xef, 0xbc,
468 0x52, 0x85, 0x3c, 0x9e, 0x8c, 0xa6, 0xf9, 0x3c, 0xd2, 0xf6, 0x6c, 0x87, 0x6c, 0x8d, 0x85, 0x88,
469 0xd2, 0x24, 0x44, 0x70, 0x6e, 0x93, 0x01, 0xd6, 0xed, 0x1a, 0x2a, 0xa5, 0xab, 0x5b, 0x95, 0xca,
470 0xb2, 0x9a, 0xe3, 0x2c, 0x17, 0x6d, 0x07, 0x27, 0x54, 0xdd, 0xf6, 0x03, 0x9c, 0xa3, 0x09, 0x55,
471 0xb7, 0x79, 0x78, 0xcf, 0xc2, 0x84, 0x61, 0xd0, 0x77, 0x36, 0x0d, 0x8d, 0x9d, 0xb1, 0xdc, 0xa2,
472 0x1c, 0x08, 0x96, 0x61, 0xac, 0x50, 0x03, 0x96, 0xe3, 0xae, 0xf2, 0x00, 0xdc, 0xd0, 0x09, 0x96,
473 0x08, 0x1c, 0xef, 0x7a, 0xcb, 0x30, 0xf4, 0x2c, 0x4c, 0xb4, 0x0e, 0xba, 0x81, 0x4a, 0x60, 0xc4,
474 0xd6, 0x41, 0x18, 0x76, 0x3f, 0x4c, 0xb6, 0xf6, 0x5b, 0xdd, 0xb8, 0x53, 0x22, 0x4e, 0x69, 0xed,
475 0xb7, 0xc2, 0xc0, 0xdb, 0xc8, 0x81, 0xdb, 0x41, 0x86, 0xee, 0xa1, 0x5a, 0xf1, 0x46, 0xd1, 0x5c,
476 0xe8, 0x50, 0xe6, 0x41, 0x36, 0x0c, 0x0d, 0x59, 0xfa, 0x6e, 0x03, 0x69, 0xba, 0x83, 0x2c, 0xdd,
477 0x2d, 0x1e, 0x17, 0x8d, 0x0b, 0x86, 0x51, 0x21, 0xbd, 0x65, 0xd2, 0xa9, 0x9c, 0x82, 0x71, 0x7b,
478 0xf7, 0x19, 0x83, 0xa6, 0xa4, 0xd6, 0x72, 0xd0, 0x9e, 0xf9, 0x5c, 0xf1, 0x56, 0x12, 0xdf, 0x31,
479 0xdc, 0x41, 0x12, 0x72, 0x8b, 0x34, 0x2b, 0x77, 0x82, 0x6c, 0xb8, 0xfb, 0xba, 0xd3, 0x22, 0x35,
480 0xd9, 0x6d, 0xe9, 0x06, 0x2a, 0xde, 0x46, 0x4d, 0x69, 0xfb, 0x06, 0x6f, 0xc6, 0x4b, 0xc2, 0xbd,
481 0x6a, 0xee, 0x79, 0x9c, 0xf1, 0x0e, 0xba, 0x24, 0x48, 0x1b, 0x63, 0x9b, 0x05, 0x19, 0x87, 0x22,
482 0x30, 0xf0, 0x2c, 0x31, 0x2b, 0xb4, 0xf6, 0x5b, 0xe2, 0xb8, 0xb7, 0xc0, 0x28, 0xb6, 0xec, 0x0c,
483 0x7a, 0x27, 0x15, 0x64, 0xad, 0x7d, 0x61, 0xc4, 0x33, 0x70, 0x0c, 0x1b, 0x35, 0x91, 0xa7, 0xd7,
484 0x74, 0x4f, 0x17, 0xac, 0xef, 0x22, 0xd6, 0x38, 0xee, 0xeb, 0xac, 0x33, 0xe0, 0xa7, 0xd3, 0xde,
485 0x3d, 0xf0, 0x33, 0xeb, 0x6e, 0xea, 0x27, 0x6e, 0xe3, 0xb9, 0xf5, 0x91, 0x89, 0xee, 0x99, 0x12,
486 0xe4, 0xc5, 0xc4, 0x57, 0xb2, 0x40, 0x53, 0x5f, 0x96, 0xb0, 0x0a, 0x5a, 0xda, 0x5c, 0xc6, 0xfa,
487 0xe5, 0xa9, 0x8a, 0x9c, 0xc0, 0x3a, 0x6a, 0x6d, 0x75, 0xbb, 0xa2, 0xa9, 0x3b, 0x1b, 0xdb, 0xab,
488 0xeb, 0x15, 0x39, 0x29, 0x0a, 0xf6, 0xef, 0x26, 0xa0, 0x10, 0x3c, 0x7b, 0x29, 0x9f, 0x81, 0x1b,
489 0xf9, 0x45, 0x89, 0x8b, 0x3c, 0xed, 0xaa, 0xe9, 0x90, 0xb5, 0xd8, 0xd4, 0xe9, 0xbe, 0xe8, 0x67,
490 0xc3, 0x24, 0xb3, 0xaa, 0x22, 0xef, 0x71, 0xd3, 0xc1, 0x2b, 0xad, 0xa9, 0x7b, 0xca, 0x1a, 0x1c,
491 0xb7, 0x6c, 0xcd, 0xf5, 0x74, 0xab, 0xa6, 0x3b, 0x35, 0xad, 0x73, 0x45, 0xa5, 0xe9, 0x86, 0x81,
492 0x5c, 0xd7, 0xa6, 0x7b, 0xa0, 0xcf, 0xf2, 0x69, 0xcb, 0xae, 0x32, 0xe3, 0xce, 0xe6, 0x50, 0x66,
493 0xa6, 0xa1, 0xcc, 0x4d, 0xf6, 0xca, 0xdc, 0x4f, 0x41, 0xb6, 0xa9, 0xb7, 0x34, 0x64, 0x79, 0xce,
494 0x01, 0x51, 0xdc, 0x19, 0x35, 0xd3, 0xd4, 0x5b, 0x15, 0xfc, 0xfc, 0xf1, 0x1c, 0x7c, 0x7e, 0x94,
495 0x84, 0xbc, 0xa8, 0xba, 0xf1, 0x21, 0xc6, 0x20, 0x1b, 0x94, 0x44, 0x4a, 0xd8, 0x2d, 0x7d, 0x35,
496 0xfa, 0xdc, 0x12, 0xde, 0xb9, 0x4a, 0xc3, 0x54, 0x0b, 0xab, 0x14, 0x89, 0x55, 0x03, 0x4e, 0x2d,
497 0x44, 0xb5, 0x47, 0x46, 0x65, 0x4f, 0xca, 0x0a, 0x0c, 0x3f, 0xe3, 0x12, 0xee, 0x61, 0xc2, 0x7d,
498 0x6b, 0x7f, 0xee, 0x47, 0xaa, 0x84, 0x3c, 0xfb, 0x48, 0x55, 0xdb, 0xd8, 0x54, 0xd7, 0xcb, 0x6b,
499 0x2a, 0x83, 0x2b, 0x37, 0x41, 0xaa, 0xa1, 0x3f, 0x7f, 0x10, 0xdc, 0xe3, 0x48, 0xd3, 0xa0, 0x81,
500 0xbf, 0x09, 0x52, 0x57, 0x91, 0x7e, 0x39, 0xb8, 0xb3, 0x90, 0xa6, 0x8f, 0x30, 0xf5, 0xe7, 0x21,
501 0x4d, 0xe2, 0xa5, 0x00, 0xb0, 0x88, 0xc9, 0x43, 0x4a, 0x06, 0x52, 0x4b, 0x9b, 0x2a, 0x4e, 0x7f,
502 0x19, 0xf2, 0xb4, 0x55, 0xdb, 0x5a, 0xad, 0x2c, 0x55, 0xe4, 0xc4, 0xcc, 0x59, 0x18, 0xa6, 0x41,
503 0xc0, 0x4b, 0xc3, 0x0f, 0x83, 0x3c, 0xc4, 0x1e, 0x19, 0x87, 0xc4, 0x7b, 0x77, 0xd6, 0x17, 0x2b,
504 0xaa, 0x9c, 0x10, 0xa7, 0xd7, 0x85, 0xbc, 0x28, 0xb8, 0x3f, 0x9e, 0x9c, 0xfa, 0xb6, 0x04, 0x39,
505 0x41, 0x40, 0x63, 0xe5, 0xa3, 0x37, 0x1a, 0xf6, 0x55, 0x4d, 0x6f, 0x98, 0xba, 0xcb, 0x92, 0x02,
506 0x48, 0x53, 0x19, 0xb7, 0x0c, 0x3a, 0x69, 0x1f, 0x8b, 0xf3, 0xaf, 0x48, 0x20, 0x87, 0xb5, 0x6b,
507 0xc8, 0x41, 0xe9, 0x27, 0xea, 0xe0, 0xcb, 0x12, 0x14, 0x82, 0x82, 0x35, 0xe4, 0xde, 0xc9, 0x9f,
508 0xa8, 0x7b, 0x6f, 0x26, 0x60, 0x34, 0x20, 0x53, 0x07, 0xf5, 0xee, 0x59, 0x18, 0x37, 0x6b, 0xa8,
509 0xd9, 0xb2, 0x3d, 0x64, 0x19, 0x07, 0x5a, 0x03, 0x5d, 0x41, 0x8d, 0xe2, 0x0c, 0x29, 0x14, 0xf3,
510 0xfd, 0x85, 0xf0, 0xdc, 0x6a, 0x07, 0xb7, 0x86, 0x61, 0xa5, 0x89, 0xd5, 0xe5, 0xca, 0xfa, 0xd6,
511 0xe6, 0x76, 0x65, 0x63, 0xe9, 0x49, 0x6d, 0x67, 0xe3, 0xd1, 0x8d, 0xcd, 0xc7, 0x37, 0x54, 0xd9,
512 0x0c, 0x99, 0x7d, 0x84, 0x4b, 0x7d, 0x0b, 0xe4, 0xb0, 0x53, 0xca, 0x8d, 0x10, 0xe5, 0x96, 0x3c,
513 0xa4, 0x4c, 0xc0, 0xd8, 0xc6, 0xa6, 0x56, 0x5d, 0x5d, 0xae, 0x68, 0x95, 0x8b, 0x17, 0x2b, 0x4b,
514 0xdb, 0x55, 0x7a, 0xb5, 0xe1, 0x5b, 0x6f, 0x07, 0x17, 0xf5, 0x4b, 0x49, 0x98, 0x88, 0xf0, 0x44,
515 0x29, 0xb3, 0x43, 0x09, 0x3d, 0x27, 0xdd, 0x3d, 0x88, 0xf7, 0x73, 0x58, 0x15, 0x6c, 0xe9, 0x8e,
516 0xc7, 0xce, 0x30, 0x77, 0x02, 0x8e, 0x92, 0xe5, 0x99, 0x7b, 0x26, 0x72, 0xd8, 0x4d, 0x10, 0x3d,
517 0xa9, 0x8c, 0x75, 0xda, 0xe9, 0x65, 0xd0, 0x5d, 0xa0, 0xb4, 0x6c, 0xd7, 0xf4, 0xcc, 0x2b, 0x48,
518 0x33, 0x2d, 0x7e, 0x6d, 0x84, 0x4f, 0x2e, 0x29, 0x55, 0xe6, 0x3d, 0xab, 0x96, 0xe7, 0x5b, 0x5b,
519 0xa8, 0xae, 0x87, 0xac, 0x71, 0x01, 0x4f, 0xaa, 0x32, 0xef, 0xf1, 0xad, 0x4f, 0x42, 0xbe, 0x66,
520 0xb7, 0xb1, 0x9c, 0xa3, 0x76, 0x78, 0xbf, 0x90, 0xd4, 0x1c, 0x6d, 0xf3, 0x4d, 0x98, 0x50, 0xef,
521 0xdc, 0x57, 0xe5, 0xd5, 0x1c, 0x6d, 0xa3, 0x26, 0x77, 0xc0, 0x98, 0x5e, 0xaf, 0x3b, 0x98, 0x9c,
522 0x13, 0xd1, 0xa3, 0x47, 0xc1, 0x6f, 0x26, 0x86, 0x53, 0x8f, 0x40, 0x86, 0xc7, 0x01, 0x6f, 0xc9,
523 0x38, 0x12, 0x5a, 0x8b, 0x9e, 0xa7, 0x13, 0xb3, 0x59, 0x35, 0x63, 0xf1, 0xce, 0x93, 0x90, 0x37,
524 0x5d, 0xad, 0x73, 0xfd, 0x9e, 0x38, 0x91, 0x98, 0xcd, 0xa8, 0x39, 0xd3, 0xf5, 0xaf, 0x2e, 0x67,
525 0x5e, 0x4b, 0x40, 0x21, 0xf8, 0xf9, 0x40, 0x59, 0x86, 0x4c, 0xc3, 0x36, 0x74, 0x92, 0x5a, 0xf4,
526 0xdb, 0xd5, 0x6c, 0xcc, 0x17, 0x87, 0xb9, 0x35, 0x66, 0xaf, 0xfa, 0xc8, 0xa9, 0x7f, 0x92, 0x20,
527 0xc3, 0x9b, 0x95, 0x63, 0x90, 0x6a, 0xe9, 0xde, 0x3e, 0xa1, 0x4b, 0x2f, 0x26, 0x64, 0x49, 0x25,
528 0xcf, 0xb8, 0xdd, 0x6d, 0xe9, 0x16, 0x49, 0x01, 0xd6, 0x8e, 0x9f, 0xf1, 0xbc, 0x36, 0x90, 0x5e,
529 0x23, 0xe7, 0x1a, 0xbb, 0xd9, 0x44, 0x96, 0xe7, 0xf2, 0x79, 0x65, 0xed, 0x4b, 0xac, 0x59, 0x39,
530 0x0d, 0xe3, 0x9e, 0xa3, 0x9b, 0x8d, 0x80, 0x6d, 0x8a, 0xd8, 0xca, 0xbc, 0xc3, 0x37, 0x2e, 0xc1,
531 0x4d, 0x9c, 0xb7, 0x86, 0x3c, 0xdd, 0xd8, 0x47, 0xb5, 0x0e, 0x68, 0x98, 0xdc, 0x5f, 0xdc, 0xc8,
532 0x0c, 0x96, 0x59, 0x3f, 0xc7, 0xce, 0x7c, 0x5f, 0x82, 0x71, 0x7e, 0x12, 0xab, 0xf9, 0xc1, 0x5a,
533 0x07, 0xd0, 0x2d, 0xcb, 0xf6, 0xc4, 0x70, 0x75, 0xa7, 0x72, 0x17, 0x6e, 0xae, 0xec, 0x83, 0x54,
534 0x81, 0x60, 0xaa, 0x09, 0xd0, 0xe9, 0xe9, 0x19, 0xb6, 0xe3, 0x90, 0x63, 0xdf, 0x86, 0xc8, 0x07,
535 0x46, 0x7a, 0x76, 0x07, 0xda, 0x84, 0x8f, 0x6c, 0xca, 0x24, 0xa4, 0x77, 0x51, 0xdd, 0xb4, 0xd8,
536 0x8d, 0x2f, 0x7d, 0xe0, 0x37, 0x2c, 0x29, 0xff, 0x86, 0x65, 0xf1, 0x73, 0x30, 0x61, 0xd8, 0xcd,
537 0xb0, 0xbb, 0x8b, 0x72, 0xe8, 0xfe, 0xc0, 0xbd, 0x24, 0x3d, 0x05, 0x1d, 0x89, 0xf9, 0xbe, 0x24,
538 0x7d, 0x29, 0x91, 0x5c, 0xd9, 0x5a, 0xfc, 0x6a, 0x62, 0x6a, 0x85, 0x42, 0xb7, 0xf8, 0x9b, 0xaa,
539 0x68, 0xaf, 0x81, 0x0c, 0xec, 0x3d, 0x7c, 0xf9, 0x34, 0xdc, 0x5d, 0x37, 0xbd, 0xfd, 0xf6, 0xee,
540 0x9c, 0x61, 0x37, 0xe7, 0xeb, 0x76, 0xdd, 0xee, 0x7c, 0x53, 0xc5, 0x4f, 0xe4, 0x81, 0xfc, 0xc5,
541 0xbe, 0xab, 0x66, 0xfd, 0xd6, 0xa9, 0xd8, 0x8f, 0xb0, 0xa5, 0x0d, 0x98, 0x60, 0xc6, 0x1a, 0xf9,
542 0xb0, 0x43, 0x8f, 0x27, 0x4a, 0xdf, 0xcb, 0xb1, 0xe2, 0xd7, 0xdf, 0x22, 0xdb, 0xb5, 0x3a, 0xce,
543 0xa0, 0xb8, 0x8f, 0x9e, 0x60, 0x4a, 0x2a, 0xdc, 0x10, 0xe0, 0xa3, 0x4b, 0x13, 0x39, 0x31, 0x8c,
544 0xdf, 0x65, 0x8c, 0x13, 0x02, 0x63, 0x95, 0x41, 0x4b, 0x4b, 0x30, 0x7a, 0x14, 0xae, 0xbf, 0x67,
545 0x5c, 0x79, 0x24, 0x92, 0xac, 0xc0, 0x18, 0x21, 0x31, 0xda, 0xae, 0x67, 0x37, 0x49, 0xdd, 0xeb,
546 0x4f, 0xf3, 0x0f, 0x6f, 0xd1, 0xb5, 0x52, 0xc0, 0xb0, 0x25, 0x1f, 0x55, 0x2a, 0x01, 0xf9, 0x96,
547 0x55, 0x43, 0x46, 0x23, 0x86, 0xe1, 0x75, 0xe6, 0x88, 0x6f, 0x5f, 0x7a, 0x0c, 0x26, 0xf1, 0xdf,
548 0xa4, 0x2c, 0x89, 0x9e, 0xc4, 0xdf, 0xa4, 0x15, 0xbf, 0xff, 0x02, 0x5d, 0x8e, 0x13, 0x3e, 0x81,
549 0xe0, 0x93, 0x30, 0x8b, 0x75, 0xe4, 0x79, 0xc8, 0x71, 0x35, 0xbd, 0x11, 0xe5, 0x9e, 0x70, 0x15,
550 0x51, 0xfc, 0xc2, 0x3b, 0xc1, 0x59, 0x5c, 0xa1, 0xc8, 0x72, 0xa3, 0x51, 0xda, 0x81, 0x1b, 0x23,
551 0xb2, 0x62, 0x00, 0xce, 0x97, 0x18, 0xe7, 0x64, 0x57, 0x66, 0x60, 0xda, 0x2d, 0xe0, 0xed, 0xfe,
552 0x5c, 0x0e, 0xc0, 0xf9, 0x7b, 0x8c, 0x53, 0x61, 0x58, 0x3e, 0xa5, 0x98, 0xf1, 0x11, 0x18, 0xbf,
553 0x82, 0x9c, 0x5d, 0xdb, 0x65, 0xd7, 0x3f, 0x03, 0xd0, 0xbd, 0xcc, 0xe8, 0xc6, 0x18, 0x90, 0xdc,
554 0x07, 0x61, 0xae, 0x07, 0x20, 0xb3, 0xa7, 0x1b, 0x68, 0x00, 0x8a, 0x2f, 0x32, 0x8a, 0x11, 0x6c,
555 0x8f, 0xa1, 0x65, 0xc8, 0xd7, 0x6d, 0xb6, 0x33, 0xc5, 0xc3, 0x5f, 0x61, 0xf0, 0x1c, 0xc7, 0x30,
556 0x8a, 0x96, 0xdd, 0x6a, 0x37, 0xf0, 0xb6, 0x15, 0x4f, 0xf1, 0xfb, 0x9c, 0x82, 0x63, 0x18, 0xc5,
557 0x11, 0xc2, 0xfa, 0x07, 0x9c, 0xc2, 0x15, 0xe2, 0xf9, 0x30, 0xe4, 0x6c, 0xab, 0x71, 0x60, 0x5b,
558 0x83, 0x38, 0xf1, 0x2a, 0x63, 0x00, 0x06, 0xc1, 0x04, 0x17, 0x20, 0x3b, 0xe8, 0x44, 0xfc, 0xd1,
559 0x3b, 0x7c, 0x79, 0xf0, 0x19, 0x58, 0x81, 0x31, 0x5e, 0xa0, 0x4c, 0xdb, 0x1a, 0x80, 0xe2, 0xcb,
560 0x8c, 0xa2, 0x20, 0xc0, 0xd8, 0x6b, 0x78, 0xc8, 0xf5, 0xea, 0x68, 0x10, 0x92, 0xd7, 0xf8, 0x6b,
561 0x30, 0x08, 0x0b, 0xe5, 0x2e, 0xb2, 0x8c, 0xfd, 0xc1, 0x18, 0xbe, 0xc2, 0x43, 0xc9, 0x31, 0x98,
562 0x62, 0x09, 0x46, 0x9b, 0xba, 0xe3, 0xee, 0xeb, 0x8d, 0x81, 0xa6, 0xe3, 0x8f, 0x19, 0x47, 0xde,
563 0x07, 0xb1, 0x88, 0xb4, 0xad, 0xa3, 0xd0, 0x7c, 0x95, 0x47, 0x44, 0x80, 0xb1, 0xa5, 0xe7, 0x7a,
564 0xe4, 0xae, 0xec, 0x28, 0x6c, 0x7f, 0xc2, 0x97, 0x1e, 0xc5, 0xae, 0x8b, 0x8c, 0x17, 0x20, 0xeb,
565 0x9a, 0xcf, 0x0f, 0x44, 0xf3, 0xa7, 0x7c, 0xa6, 0x09, 0x00, 0x83, 0x9f, 0x84, 0x9b, 0x22, 0xb7,
566 0x89, 0x01, 0xc8, 0xfe, 0x8c, 0x91, 0x1d, 0x8b, 0xd8, 0x2a, 0x58, 0x49, 0x38, 0x2a, 0xe5, 0x9f,
567 0xf3, 0x92, 0x80, 0x42, 0x5c, 0x5b, 0xf8, 0xac, 0xe0, 0xea, 0x7b, 0x47, 0x8b, 0xda, 0x5f, 0xf0,
568 0xa8, 0x51, 0x6c, 0x20, 0x6a, 0xdb, 0x70, 0x8c, 0x31, 0x1e, 0x6d, 0x5e, 0xbf, 0xc6, 0x0b, 0x2b,
569 0x45, 0xef, 0x04, 0x67, 0xf7, 0x73, 0x30, 0xe5, 0x87, 0x93, 0x8b, 0x52, 0x57, 0x6b, 0xea, 0xad,
570 0x01, 0x98, 0xbf, 0xce, 0x98, 0x79, 0xc5, 0xf7, 0x55, 0xad, 0xbb, 0xae, 0xb7, 0x30, 0xf9, 0x13,
571 0x50, 0xe4, 0xe4, 0x6d, 0xcb, 0x41, 0x86, 0x5d, 0xb7, 0xcc, 0xe7, 0x51, 0x6d, 0x00, 0xea, 0xbf,
572 0x0c, 0x4d, 0xd5, 0x8e, 0x00, 0xc7, 0xcc, 0xab, 0x20, 0xfb, 0x5a, 0x45, 0x33, 0x9b, 0x2d, 0xdb,
573 0xf1, 0x62, 0x18, 0xff, 0x8a, 0xcf, 0x94, 0x8f, 0x5b, 0x25, 0xb0, 0x52, 0x05, 0x0a, 0xe4, 0x71,
574 0xd0, 0x94, 0xfc, 0x6b, 0x46, 0x34, 0xda, 0x41, 0xb1, 0xc2, 0x61, 0xd8, 0xcd, 0x96, 0xee, 0x0c,
575 0x52, 0xff, 0xfe, 0x86, 0x17, 0x0e, 0x06, 0x61, 0x85, 0xc3, 0x3b, 0x68, 0x21, 0xbc, 0xdb, 0x0f,
576 0xc0, 0xf0, 0x0d, 0x5e, 0x38, 0x38, 0x86, 0x51, 0x70, 0xc1, 0x30, 0x00, 0xc5, 0xdf, 0x72, 0x0a,
577 0x8e, 0xc1, 0x14, 0x9f, 0xed, 0x6c, 0xb4, 0x0e, 0xaa, 0x9b, 0xae, 0xe7, 0x50, 0x29, 0xdc, 0x9f,
578 0xea, 0x9b, 0xef, 0x04, 0x45, 0x98, 0x2a, 0x40, 0x71, 0x25, 0x62, 0x57, 0xa8, 0xe4, 0xa4, 0x14,
579 0xef, 0xd8, 0xb7, 0x78, 0x25, 0x12, 0x60, 0xd8, 0x37, 0x41, 0x21, 0xe2, 0xb0, 0x1b, 0xf8, 0x7c,
580 0x30, 0x00, 0xdd, 0xb7, 0x43, 0xce, 0x55, 0x39, 0x16, 0x73, 0x0a, 0xfa, 0xa7, 0x6d, 0x5d, 0x46,
581 0x07, 0x03, 0x65, 0xe7, 0xdf, 0x85, 0xf4, 0xcf, 0x0e, 0x45, 0xd2, 0x1a, 0x32, 0x16, 0xd2, 0x53,
582 0x4a, 0xdc, 0xaf, 0x80, 0x8a, 0x3f, 0xf7, 0x1e, 0x7b, 0xdf, 0xa0, 0x9c, 0x2a, 0xad, 0xe1, 0x24,
583 0x0f, 0x8a, 0x9e, 0x78, 0xb2, 0x17, 0xde, 0xf3, 0xf3, 0x3c, 0xa0, 0x79, 0x4a, 0x17, 0x61, 0x34,
584 0x20, 0x78, 0xe2, 0xa9, 0x7e, 0x9e, 0x51, 0xe5, 0x45, 0xbd, 0x53, 0x3a, 0x0b, 0x29, 0x2c, 0x5e,
585 0xe2, 0xe1, 0xbf, 0xc0, 0xe0, 0xc4, 0xbc, 0xf4, 0x20, 0x64, 0xb8, 0x68, 0x89, 0x87, 0xfe, 0x22,
586 0x83, 0xfa, 0x10, 0x0c, 0xe7, 0x82, 0x25, 0x1e, 0xfe, 0x4b, 0x1c, 0xce, 0x21, 0x18, 0x3e, 0x78,
587 0x08, 0xbf, 0xf3, 0xcb, 0x29, 0xb6, 0xe9, 0xf0, 0xd8, 0x5d, 0x80, 0x11, 0xa6, 0x54, 0xe2, 0xd1,
588 0x9f, 0x67, 0x83, 0x73, 0x44, 0xe9, 0x7e, 0x48, 0x0f, 0x18, 0xf0, 0x5f, 0x65, 0x50, 0x6a, 0x5f,
589 0x5a, 0x82, 0x9c, 0xa0, 0x4e, 0xe2, 0xe1, 0xbf, 0xc6, 0xe0, 0x22, 0x0a, 0xbb, 0xce, 0xd4, 0x49,
590 0x3c, 0xc1, 0xaf, 0x73, 0xd7, 0x19, 0x02, 0x87, 0x8d, 0x0b, 0x93, 0x78, 0xf4, 0x6f, 0xf0, 0xa8,
591 0x73, 0x48, 0xe9, 0x61, 0xc8, 0xfa, 0x9b, 0x4d, 0x3c, 0xfe, 0x37, 0x19, 0xbe, 0x83, 0xc1, 0x11,
592 0x10, 0x36, 0xbb, 0x78, 0x8a, 0xdf, 0xe2, 0x11, 0x10, 0x50, 0x78, 0x19, 0x85, 0x05, 0x4c, 0x3c,
593 0xd3, 0x6f, 0xf3, 0x65, 0x14, 0xd2, 0x2f, 0x78, 0x36, 0x49, 0xcd, 0x8f, 0xa7, 0xf8, 0x1d, 0x3e,
594 0x9b, 0xc4, 0x1e, 0xbb, 0x11, 0x56, 0x04, 0xf1, 0x1c, 0xbf, 0xcb, 0xdd, 0x08, 0x09, 0x82, 0xd2,
595 0x16, 0x28, 0xdd, 0x6a, 0x20, 0x9e, 0xef, 0x45, 0xc6, 0x37, 0xde, 0x25, 0x06, 0x4a, 0x8f, 0xc3,
596 0xb1, 0x68, 0x25, 0x10, 0xcf, 0xfa, 0x85, 0xf7, 0x42, 0x67, 0x37, 0x51, 0x08, 0x94, 0xb6, 0x3b,
597 0x5b, 0x8a, 0xa8, 0x02, 0xe2, 0x69, 0x5f, 0x7a, 0x2f, 0x58, 0xb8, 0x45, 0x11, 0x50, 0x2a, 0x03,
598 0x74, 0x36, 0xe0, 0x78, 0xae, 0x97, 0x19, 0x97, 0x00, 0xc2, 0x4b, 0x83, 0xed, 0xbf, 0xf1, 0xf8,
599 0x2f, 0xf2, 0xa5, 0xc1, 0x10, 0x78, 0x69, 0xf0, 0xad, 0x37, 0x1e, 0xfd, 0x0a, 0x5f, 0x1a, 0x1c,
600 0x82, 0x33, 0x5b, 0xd8, 0xdd, 0xe2, 0x19, 0x5e, 0xe5, 0x99, 0x2d, 0xa0, 0x4a, 0x1b, 0x30, 0xde,
601 0xb5, 0x21, 0xc6, 0x53, 0x7d, 0x89, 0x51, 0xc9, 0xe1, 0xfd, 0x50, 0xdc, 0xbc, 0xd8, 0x66, 0x18,
602 0xcf, 0xf6, 0x87, 0xa1, 0xcd, 0x8b, 0xed, 0x85, 0xa5, 0x0b, 0x90, 0xb1, 0xda, 0x8d, 0x06, 0x5e,
603 0x3c, 0x4a, 0xff, 0x5f, 0xee, 0x15, 0xff, 0xe5, 0x03, 0x16, 0x1d, 0x0e, 0x28, 0x9d, 0x85, 0x34,
604 0x6a, 0xee, 0xa2, 0x5a, 0x1c, 0xf2, 0x5f, 0x3f, 0xe0, 0x05, 0x13, 0x5b, 0x97, 0x1e, 0x06, 0xa0,
605 0x57, 0x23, 0xe4, 0xb3, 0x5f, 0x0c, 0xf6, 0xdf, 0x3e, 0x60, 0xbf, 0xa9, 0xe9, 0x40, 0x3a, 0x04,
606 0xf4, 0x17, 0x3a, 0xfd, 0x09, 0xde, 0x09, 0x12, 0x90, 0x19, 0x79, 0x00, 0x46, 0x9e, 0x71, 0x6d,
607 0xcb, 0xd3, 0xeb, 0x71, 0xe8, 0x7f, 0x67, 0x68, 0x6e, 0x8f, 0x03, 0xd6, 0xb4, 0x1d, 0xe4, 0xe9,
608 0x75, 0x37, 0x0e, 0xfb, 0x1f, 0x0c, 0xeb, 0x03, 0x30, 0xd8, 0xd0, 0x5d, 0x6f, 0x90, 0xf7, 0xfe,
609 0x4f, 0x0e, 0xe6, 0x00, 0xec, 0x34, 0xfe, 0xfb, 0x32, 0x3a, 0x88, 0xc3, 0xbe, 0xcb, 0x9d, 0x66,
610 0xf6, 0xa5, 0x07, 0x21, 0x8b, 0xff, 0xa4, 0x3f, 0x94, 0x8b, 0x01, 0xff, 0x17, 0x03, 0x77, 0x10,
611 0x78, 0x64, 0xd7, 0xab, 0x79, 0x66, 0x7c, 0xb0, 0xff, 0x9b, 0xcd, 0x34, 0xb7, 0x2f, 0x95, 0x21,
612 0xe7, 0x7a, 0xb5, 0x5a, 0x9b, 0xe9, 0xd3, 0x18, 0xf8, 0xff, 0x7c, 0xe0, 0x5f, 0x59, 0xf8, 0x18,
613 0x3c, 0xdb, 0x57, 0x2f, 0x7b, 0x2d, 0x9b, 0x7c, 0xe6, 0x88, 0x63, 0x78, 0x8f, 0x31, 0x08, 0x90,
614 0xc5, 0x4a, 0xf4, 0xf5, 0x2d, 0xac, 0xd8, 0x2b, 0x36, 0xbd, 0xb8, 0x7d, 0x6a, 0x26, 0xfe, 0x06,
615 0x16, 0xfe, 0xf7, 0x6e, 0xb8, 0xc5, 0xb0, 0x9b, 0xbb, 0xb6, 0x3b, 0x2f, 0x14, 0xf3, 0xf9, 0xa6,
616 0xde, 0x72, 0x89, 0xc1, 0x02, 0xbb, 0x9e, 0xcd, 0xb1, 0x27, 0xdc, 0x31, 0x75, 0xb4, 0xab, 0xdd,
617 0x99, 0x9b, 0x61, 0xf4, 0x62, 0xc3, 0xd6, 0x3d, 0xd3, 0xaa, 0x6f, 0x61, 0xef, 0x95, 0x3c, 0x48,
618 0x7b, 0xe4, 0xd3, 0xa4, 0xa4, 0x4a, 0x7b, 0x33, 0xff, 0x98, 0x86, 0x2c, 0xbd, 0x15, 0x5c, 0xd7,
619 0x5b, 0xca, 0xcf, 0x42, 0x7e, 0x83, 0x2d, 0xc5, 0x7b, 0x17, 0xce, 0xbb, 0xfe, 0x57, 0x08, 0x61,
620 0xfc, 0x39, 0xdf, 0x7a, 0x4e, 0x34, 0x25, 0x3f, 0x45, 0x58, 0xbc, 0xe7, 0x87, 0x6f, 0x1c, 0xbf,
621 0xab, 0xa7, 0x7f, 0x58, 0x5c, 0xcc, 0xd3, 0x35, 0x33, 0xb7, 0x63, 0x5a, 0xde, 0xbd, 0x0b, 0xe7,
622 0xd5, 0xc0, 0x78, 0xca, 0x15, 0xc8, 0xb0, 0x0e, 0x97, 0x7d, 0x9d, 0xba, 0xb5, 0xc7, 0xd8, 0xdc,
623 0x8c, 0x8e, 0x7b, 0xe6, 0xf5, 0x37, 0x8e, 0x0f, 0x1d, 0x79, 0x6c, 0x7f, 0x2c, 0xe5, 0x59, 0xc8,
624 0x71, 0x3f, 0x56, 0x6b, 0x2e, 0xfb, 0x6f, 0x0e, 0x77, 0xc4, 0xbc, 0xf6, 0x6a, 0x8d, 0x8d, 0x7e,
625 0xfb, 0x0f, 0xdf, 0x38, 0x3e, 0xd3, 0x77, 0xe4, 0xb9, 0x9d, 0xb6, 0x59, 0x53, 0xc5, 0x31, 0x94,
626 0xa7, 0x21, 0x89, 0x87, 0xa2, 0xbf, 0x0c, 0x3d, 0xde, 0x63, 0x28, 0x7f, 0x88, 0x53, 0xec, 0x05,
627 0x07, 0x19, 0x06, 0xf3, 0x4e, 0x3d, 0x0c, 0xe3, 0x5d, 0xd3, 0xa3, 0xc8, 0x90, 0xbc, 0x8c, 0x0e,
628 0xd8, 0x4f, 0xf0, 0xf0, 0x9f, 0xca, 0x64, 0xe7, 0x37, 0xb2, 0xd2, 0x6c, 0x9e, 0xfd, 0xf0, 0xb5,
629 0x94, 0x38, 0x2f, 0x4d, 0x5d, 0x80, 0xd1, 0x40, 0x8c, 0x8f, 0x04, 0x7e, 0x08, 0xe4, 0x70, 0x94,
630 0x8e, 0x84, 0x3f, 0x07, 0x99, 0x0f, 0x83, 0x9b, 0xf9, 0x81, 0x02, 0x23, 0xe5, 0x46, 0x63, 0x5d,
631 0x6f, 0xb9, 0xca, 0x93, 0x30, 0x4e, 0x8f, 0x40, 0xdb, 0xf6, 0x32, 0xf9, 0x1e, 0xb8, 0xae, 0xb7,
632 0x58, 0x42, 0x9f, 0x0e, 0x84, 0x9b, 0x01, 0xe6, 0xba, 0xac, 0xc9, 0xf8, 0x6a, 0x37, 0x8b, 0xf2,
633 0x18, 0xc8, 0xbc, 0x91, 0xac, 0x2d, 0xcc, 0x4c, 0xd3, 0xf5, 0x54, 0x5f, 0x66, 0x6e, 0x4c, 0x89,
634 0xbb, 0x38, 0x94, 0x87, 0x20, 0xb3, 0x6a, 0x79, 0xf7, 0x2d, 0x60, 0x3e, 0x9a, 0x83, 0x33, 0x91,
635 0x7c, 0xdc, 0x88, 0xf2, 0xf8, 0x18, 0x86, 0x3f, 0x77, 0x06, 0xe3, 0x53, 0xfd, 0xf1, 0xc4, 0xa8,
636 0x83, 0x27, 0x8f, 0x4a, 0x19, 0xb2, 0x78, 0xce, 0xa9, 0x03, 0xf4, 0x7f, 0xd8, 0xdc, 0x12, 0x49,
637 0xe0, 0x5b, 0x51, 0x86, 0x0e, 0x8a, 0x53, 0x50, 0x1f, 0x86, 0x63, 0x28, 0x04, 0x27, 0x3a, 0x28,
638 0x4c, 0x51, 0xf5, 0xbd, 0x18, 0xe9, 0x43, 0x51, 0x0d, 0x79, 0x51, 0x15, 0xbd, 0xa8, 0xfa, 0x5e,
639 0x64, 0x62, 0x28, 0x44, 0x2f, 0xfc, 0x67, 0x65, 0x19, 0xe0, 0xa2, 0xf9, 0x1c, 0xaa, 0x51, 0x37,
640 0xb2, 0x11, 0xc5, 0x88, 0x73, 0x74, 0xcc, 0x28, 0x89, 0x80, 0x53, 0x56, 0x20, 0x57, 0xdd, 0xeb,
641 0xd0, 0x00, 0xfb, 0x0f, 0x46, 0x91, 0xae, 0xec, 0x85, 0x78, 0x44, 0xa4, 0xef, 0x0e, 0x7d, 0xa5,
642 0x5c, 0x9c, 0x3b, 0xc2, 0x3b, 0x09, 0xb8, 0x8e, 0x3b, 0x94, 0x26, 0x1f, 0xeb, 0x8e, 0xc0, 0x23,
643 0x22, 0x95, 0x0b, 0x30, 0xb2, 0x68, 0xdb, 0xd8, 0xb2, 0x38, 0x4a, 0x48, 0x4e, 0x46, 0x92, 0x30,
644 0x1b, 0x4a, 0xc0, 0x11, 0x64, 0x76, 0x48, 0xea, 0x63, 0x78, 0xa1, 0xdf, 0xec, 0x70, 0x2b, 0x3e,
645 0x3b, 0xfc, 0x59, 0x5c, 0x81, 0x8b, 0x07, 0x1e, 0xc2, 0xc7, 0x8d, 0xe2, 0xd8, 0x00, 0x2b, 0x90,
646 0x1b, 0x87, 0x56, 0x20, 0x6f, 0x56, 0xaa, 0x30, 0xc6, 0xdb, 0x2a, 0x56, 0x1b, 0xd7, 0xe0, 0xa2,
647 0xcc, 0xfe, 0xf7, 0x40, 0x3f, 0x5a, 0x66, 0x4b, 0x59, 0xc3, 0x0c, 0xca, 0x16, 0x14, 0x78, 0xd3,
648 0xba, 0x4b, 0x5e, 0x7a, 0x3c, 0x62, 0x5f, 0x0d, 0x73, 0x52, 0x53, 0x4a, 0x19, 0xc2, 0x4f, 0x2d,
649 0xc3, 0xb1, 0xe8, 0x6a, 0x15, 0x57, 0x2d, 0x25, 0xb1, 0xca, 0x2e, 0xc1, 0x0d, 0x91, 0x95, 0x29,
650 0x8e, 0x24, 0x11, 0xda, 0x27, 0x02, 0xe5, 0x48, 0x04, 0xa7, 0x23, 0xc0, 0xe9, 0x6e, 0x70, 0x27,
651 0xc9, 0x44, 0x70, 0x32, 0x02, 0x9c, 0x14, 0xc1, 0x9f, 0x81, 0x42, 0xb0, 0x0e, 0x89, 0xe8, 0xd1,
652 0x08, 0xf4, 0x68, 0x04, 0x3a, 0x7a, 0xec, 0x54, 0x04, 0x3a, 0x15, 0x42, 0x57, 0x7b, 0x8e, 0x3d,
653 0x1e, 0x81, 0x1e, 0x8f, 0x40, 0x47, 0x8f, 0xad, 0x44, 0xa0, 0x15, 0x11, 0xfd, 0x20, 0x8c, 0x85,
654 0x4a, 0x8e, 0x08, 0x1f, 0x89, 0x80, 0x8f, 0x84, 0xf6, 0xe6, 0x70, 0xa9, 0x11, 0xf1, 0x63, 0x11,
655 0xf8, 0xb1, 0xa8, 0xe1, 0xa3, 0xbd, 0x1f, 0x8e, 0x80, 0x0f, 0x47, 0x0e, 0x1f, 0x8d, 0x97, 0x23,
656 0xf0, 0xb2, 0x88, 0x2f, 0x41, 0x5e, 0xac, 0x2a, 0x22, 0x36, 0x13, 0x81, 0xcd, 0x84, 0xe3, 0x1e,
657 0x28, 0x29, 0x71, 0x99, 0x9e, 0xed, 0xb1, 0x5c, 0x02, 0x65, 0xe4, 0x48, 0xca, 0xe6, 0x09, 0x98,
658 0x8c, 0x2a, 0x1a, 0x11, 0x1c, 0xa7, 0x44, 0x8e, 0xc2, 0xc2, 0x64, 0xa0, 0x58, 0x10, 0x5c, 0xbb,
659 0x29, 0x32, 0x3f, 0x0d, 0x13, 0x11, 0xa5, 0x23, 0x82, 0xf8, 0x1e, 0x91, 0x38, 0xb7, 0x30, 0x15,
660 0x20, 0x0e, 0x9c, 0x15, 0x44, 0x69, 0xf5, 0xa3, 0x09, 0x28, 0xb0, 0x12, 0xb5, 0xe9, 0xd4, 0x90,
661 0x83, 0x6a, 0xca, 0x4f, 0xf7, 0x56, 0x58, 0x0b, 0x51, 0xa5, 0x8d, 0xe1, 0x8e, 0x20, 0xb4, 0x9e,
662 0xee, 0x29, 0xb4, 0xee, 0x1d, 0x64, 0x80, 0x38, 0xbd, 0x55, 0xe9, 0xd2, 0x5b, 0x77, 0xf6, 0xa3,
663 0xed, 0x25, 0xbb, 0x2a, 0x5d, 0xb2, 0x2b, 0x8e, 0x26, 0x52, 0x7d, 0x5d, 0xea, 0x56, 0x5f, 0xa7,
664 0xfa, 0xf1, 0xf4, 0x16, 0x61, 0x97, 0xba, 0x45, 0x58, 0x2c, 0x53, 0xb4, 0x16, 0xbb, 0xd4, 0xad,
665 0xc5, 0xfa, 0x32, 0xf5, 0x96, 0x64, 0x97, 0xba, 0x25, 0x59, 0x2c, 0x53, 0xb4, 0x32, 0x7b, 0x34,
666 0x42, 0x99, 0x9d, 0xee, 0x47, 0xd5, 0x4f, 0xa0, 0x6d, 0x44, 0x09, 0xb4, 0xbb, 0xfa, 0x3a, 0xd6,
667 0x57, 0xa7, 0x3d, 0x1a, 0xa1, 0xd3, 0xe2, 0x9d, 0xeb, 0x21, 0xd7, 0x36, 0xa2, 0xe4, 0xda, 0x00,
668 0xce, 0xf5, 0x52, 0x6d, 0x8b, 0x61, 0xd5, 0x36, 0xdb, 0x8f, 0x2b, 0x5a, 0xbc, 0x5d, 0xea, 0x16,
669 0x6f, 0xa7, 0xe2, 0xd7, 0x62, 0x94, 0x86, 0x7b, 0xba, 0xa7, 0x86, 0x1b, 0x68, 0x71, 0xc7, 0x49,
670 0xb9, 0xa7, 0x7a, 0x49, 0xb9, 0x7b, 0x06, 0x61, 0xef, 0xaf, 0xe8, 0x1e, 0xef, 0xa1, 0xe8, 0xe6,
671 0x07, 0xa1, 0xfe, 0x44, 0xd8, 0x7d, 0x22, 0xec, 0x3e, 0x11, 0x76, 0x9f, 0x08, 0xbb, 0xff, 0x1f,
672 0xc2, 0xae, 0x94, 0x7a, 0xf1, 0xd5, 0xe3, 0xd2, 0xa9, 0x93, 0x30, 0xc2, 0x86, 0x56, 0x86, 0x21,
673 0xb1, 0x5e, 0x96, 0x87, 0xc8, 0xbf, 0x8b, 0xb2, 0x44, 0xfe, 0x5d, 0x92, 0x13, 0x8b, 0x6b, 0xaf,
674 0x5f, 0x9f, 0x1e, 0xfa, 0xde, 0xf5, 0xe9, 0xa1, 0x1f, 0x5c, 0x9f, 0x1e, 0x7a, 0xf3, 0xfa, 0xb4,
675 0xf4, 0xf6, 0xf5, 0x69, 0xe9, 0xdd, 0xeb, 0xd3, 0xd2, 0xfb, 0xd7, 0xa7, 0xa5, 0x6b, 0x87, 0xd3,
676 0xd2, 0x57, 0x0e, 0xa7, 0xa5, 0xaf, 0x1d, 0x4e, 0x4b, 0xdf, 0x3c, 0x9c, 0x96, 0xbe, 0x73, 0x38,
677 0x2d, 0xbd, 0x7e, 0x38, 0x3d, 0xf4, 0xbd, 0xc3, 0x69, 0xe9, 0xcd, 0xc3, 0x69, 0xe9, 0xed, 0xc3,
678 0xe9, 0xa1, 0x77, 0x0f, 0xa7, 0xa5, 0xf7, 0x0f, 0xa7, 0x87, 0xae, 0xfd, 0x78, 0x7a, 0xe8, 0xff,
679 0x02, 0x00, 0x00, 0xff, 0xff, 0x09, 0x79, 0x5f, 0xe9, 0xf0, 0x49, 0x00, 0x00,
680 }
681 r := bytes.NewReader(gzipped)
682 gzipr, err := compress_gzip.NewReader(r)
683 if err != nil {
684 panic(err)
685 }
686 ungzipped, err := io_ioutil.ReadAll(gzipr)
687 if err != nil {
688 panic(err)
689 }
690 if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
691 panic(err)
692 }
693 return d
694 }
695 func (x MapEnum) String() string {
696 s, ok := MapEnum_name[int32(x)]
697 if ok {
698 return s
699 }
700 return strconv.Itoa(int(x))
701 }
702 func (this *FloatingPoint) VerboseEqual(that interface{}) error {
703 if that == nil {
704 if this == nil {
705 return nil
706 }
707 return fmt.Errorf("that == nil && this != nil")
708 }
709
710 that1, ok := that.(*FloatingPoint)
711 if !ok {
712 that2, ok := that.(FloatingPoint)
713 if ok {
714 that1 = &that2
715 } else {
716 return fmt.Errorf("that is not of type *FloatingPoint")
717 }
718 }
719 if that1 == nil {
720 if this == nil {
721 return nil
722 }
723 return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil")
724 } else if this == nil {
725 return fmt.Errorf("that is type *FloatingPoint but is not nil && this == nil")
726 }
727 if this.F != nil && that1.F != nil {
728 if *this.F != *that1.F {
729 return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F)
730 }
731 } else if this.F != nil {
732 return fmt.Errorf("this.F == nil && that.F != nil")
733 } else if that1.F != nil {
734 return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
735 }
736 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
737 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
738 }
739 return nil
740 }
741 func (this *FloatingPoint) Equal(that interface{}) bool {
742 if that == nil {
743 return this == nil
744 }
745
746 that1, ok := that.(*FloatingPoint)
747 if !ok {
748 that2, ok := that.(FloatingPoint)
749 if ok {
750 that1 = &that2
751 } else {
752 return false
753 }
754 }
755 if that1 == nil {
756 return this == nil
757 } else if this == nil {
758 return false
759 }
760 if this.F != nil && that1.F != nil {
761 if *this.F != *that1.F {
762 return false
763 }
764 } else if this.F != nil {
765 return false
766 } else if that1.F != nil {
767 return false
768 }
769 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
770 return false
771 }
772 return true
773 }
774 func (this *CustomMap) VerboseEqual(that interface{}) error {
775 if that == nil {
776 if this == nil {
777 return nil
778 }
779 return fmt.Errorf("that == nil && this != nil")
780 }
781
782 that1, ok := that.(*CustomMap)
783 if !ok {
784 that2, ok := that.(CustomMap)
785 if ok {
786 that1 = &that2
787 } else {
788 return fmt.Errorf("that is not of type *CustomMap")
789 }
790 }
791 if that1 == nil {
792 if this == nil {
793 return nil
794 }
795 return fmt.Errorf("that is type *CustomMap but is nil && this != nil")
796 } else if this == nil {
797 return fmt.Errorf("that is type *CustomMap but is not nil && this == nil")
798 }
799 if len(this.Nullable128S) != len(that1.Nullable128S) {
800 return fmt.Errorf("Nullable128S this(%v) Not Equal that(%v)", len(this.Nullable128S), len(that1.Nullable128S))
801 }
802 for i := range this.Nullable128S {
803 if !this.Nullable128S[i].Equal(*that1.Nullable128S[i]) {
804 return fmt.Errorf("Nullable128S this[%v](%v) Not Equal that[%v](%v)", i, this.Nullable128S[i], i, that1.Nullable128S[i])
805 }
806 }
807 if len(this.Uint128S) != len(that1.Uint128S) {
808 return fmt.Errorf("Uint128S this(%v) Not Equal that(%v)", len(this.Uint128S), len(that1.Uint128S))
809 }
810 for i := range this.Uint128S {
811 if !this.Uint128S[i].Equal(that1.Uint128S[i]) {
812 return fmt.Errorf("Uint128S this[%v](%v) Not Equal that[%v](%v)", i, this.Uint128S[i], i, that1.Uint128S[i])
813 }
814 }
815 if len(this.NullableIds) != len(that1.NullableIds) {
816 return fmt.Errorf("NullableIds this(%v) Not Equal that(%v)", len(this.NullableIds), len(that1.NullableIds))
817 }
818 for i := range this.NullableIds {
819 if !this.NullableIds[i].Equal(*that1.NullableIds[i]) {
820 return fmt.Errorf("NullableIds this[%v](%v) Not Equal that[%v](%v)", i, this.NullableIds[i], i, that1.NullableIds[i])
821 }
822 }
823 if len(this.Ids) != len(that1.Ids) {
824 return fmt.Errorf("Ids this(%v) Not Equal that(%v)", len(this.Ids), len(that1.Ids))
825 }
826 for i := range this.Ids {
827 if !this.Ids[i].Equal(that1.Ids[i]) {
828 return fmt.Errorf("Ids this[%v](%v) Not Equal that[%v](%v)", i, this.Ids[i], i, that1.Ids[i])
829 }
830 }
831 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
832 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
833 }
834 return nil
835 }
836 func (this *CustomMap) Equal(that interface{}) bool {
837 if that == nil {
838 return this == nil
839 }
840
841 that1, ok := that.(*CustomMap)
842 if !ok {
843 that2, ok := that.(CustomMap)
844 if ok {
845 that1 = &that2
846 } else {
847 return false
848 }
849 }
850 if that1 == nil {
851 return this == nil
852 } else if this == nil {
853 return false
854 }
855 if len(this.Nullable128S) != len(that1.Nullable128S) {
856 return false
857 }
858 for i := range this.Nullable128S {
859 if !this.Nullable128S[i].Equal(*that1.Nullable128S[i]) {
860 return false
861 }
862 }
863 if len(this.Uint128S) != len(that1.Uint128S) {
864 return false
865 }
866 for i := range this.Uint128S {
867 if !this.Uint128S[i].Equal(that1.Uint128S[i]) {
868 return false
869 }
870 }
871 if len(this.NullableIds) != len(that1.NullableIds) {
872 return false
873 }
874 for i := range this.NullableIds {
875 if !this.NullableIds[i].Equal(*that1.NullableIds[i]) {
876 return false
877 }
878 }
879 if len(this.Ids) != len(that1.Ids) {
880 return false
881 }
882 for i := range this.Ids {
883 if !this.Ids[i].Equal(that1.Ids[i]) {
884 return false
885 }
886 }
887 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
888 return false
889 }
890 return true
891 }
892 func (this *AllMaps) VerboseEqual(that interface{}) error {
893 if that == nil {
894 if this == nil {
895 return nil
896 }
897 return fmt.Errorf("that == nil && this != nil")
898 }
899
900 that1, ok := that.(*AllMaps)
901 if !ok {
902 that2, ok := that.(AllMaps)
903 if ok {
904 that1 = &that2
905 } else {
906 return fmt.Errorf("that is not of type *AllMaps")
907 }
908 }
909 if that1 == nil {
910 if this == nil {
911 return nil
912 }
913 return fmt.Errorf("that is type *AllMaps but is nil && this != nil")
914 } else if this == nil {
915 return fmt.Errorf("that is type *AllMaps but is not nil && this == nil")
916 }
917 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
918 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
919 }
920 for i := range this.StringToDoubleMap {
921 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
922 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
923 }
924 }
925 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
926 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
927 }
928 for i := range this.StringToFloatMap {
929 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
930 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
931 }
932 }
933 if len(this.Int32Map) != len(that1.Int32Map) {
934 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
935 }
936 for i := range this.Int32Map {
937 if this.Int32Map[i] != that1.Int32Map[i] {
938 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
939 }
940 }
941 if len(this.Int64Map) != len(that1.Int64Map) {
942 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
943 }
944 for i := range this.Int64Map {
945 if this.Int64Map[i] != that1.Int64Map[i] {
946 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
947 }
948 }
949 if len(this.Uint32Map) != len(that1.Uint32Map) {
950 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
951 }
952 for i := range this.Uint32Map {
953 if this.Uint32Map[i] != that1.Uint32Map[i] {
954 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
955 }
956 }
957 if len(this.Uint64Map) != len(that1.Uint64Map) {
958 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
959 }
960 for i := range this.Uint64Map {
961 if this.Uint64Map[i] != that1.Uint64Map[i] {
962 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
963 }
964 }
965 if len(this.Sint32Map) != len(that1.Sint32Map) {
966 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
967 }
968 for i := range this.Sint32Map {
969 if this.Sint32Map[i] != that1.Sint32Map[i] {
970 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
971 }
972 }
973 if len(this.Sint64Map) != len(that1.Sint64Map) {
974 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
975 }
976 for i := range this.Sint64Map {
977 if this.Sint64Map[i] != that1.Sint64Map[i] {
978 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
979 }
980 }
981 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
982 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
983 }
984 for i := range this.Fixed32Map {
985 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
986 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
987 }
988 }
989 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
990 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
991 }
992 for i := range this.Sfixed32Map {
993 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
994 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
995 }
996 }
997 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
998 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
999 }
1000 for i := range this.Fixed64Map {
1001 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1002 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1003 }
1004 }
1005 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1006 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1007 }
1008 for i := range this.Sfixed64Map {
1009 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1010 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1011 }
1012 }
1013 if len(this.BoolMap) != len(that1.BoolMap) {
1014 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1015 }
1016 for i := range this.BoolMap {
1017 if this.BoolMap[i] != that1.BoolMap[i] {
1018 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1019 }
1020 }
1021 if len(this.StringMap) != len(that1.StringMap) {
1022 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1023 }
1024 for i := range this.StringMap {
1025 if this.StringMap[i] != that1.StringMap[i] {
1026 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1027 }
1028 }
1029 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1030 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1031 }
1032 for i := range this.StringToBytesMap {
1033 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1034 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1035 }
1036 }
1037 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1038 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1039 }
1040 for i := range this.StringToEnumMap {
1041 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1042 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1043 }
1044 }
1045 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1046 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1047 }
1048 for i := range this.StringToMsgMap {
1049 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1050 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1051 }
1052 }
1053 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1054 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1055 }
1056 return nil
1057 }
1058 func (this *AllMaps) Equal(that interface{}) bool {
1059 if that == nil {
1060 return this == nil
1061 }
1062
1063 that1, ok := that.(*AllMaps)
1064 if !ok {
1065 that2, ok := that.(AllMaps)
1066 if ok {
1067 that1 = &that2
1068 } else {
1069 return false
1070 }
1071 }
1072 if that1 == nil {
1073 return this == nil
1074 } else if this == nil {
1075 return false
1076 }
1077 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1078 return false
1079 }
1080 for i := range this.StringToDoubleMap {
1081 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1082 return false
1083 }
1084 }
1085 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1086 return false
1087 }
1088 for i := range this.StringToFloatMap {
1089 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1090 return false
1091 }
1092 }
1093 if len(this.Int32Map) != len(that1.Int32Map) {
1094 return false
1095 }
1096 for i := range this.Int32Map {
1097 if this.Int32Map[i] != that1.Int32Map[i] {
1098 return false
1099 }
1100 }
1101 if len(this.Int64Map) != len(that1.Int64Map) {
1102 return false
1103 }
1104 for i := range this.Int64Map {
1105 if this.Int64Map[i] != that1.Int64Map[i] {
1106 return false
1107 }
1108 }
1109 if len(this.Uint32Map) != len(that1.Uint32Map) {
1110 return false
1111 }
1112 for i := range this.Uint32Map {
1113 if this.Uint32Map[i] != that1.Uint32Map[i] {
1114 return false
1115 }
1116 }
1117 if len(this.Uint64Map) != len(that1.Uint64Map) {
1118 return false
1119 }
1120 for i := range this.Uint64Map {
1121 if this.Uint64Map[i] != that1.Uint64Map[i] {
1122 return false
1123 }
1124 }
1125 if len(this.Sint32Map) != len(that1.Sint32Map) {
1126 return false
1127 }
1128 for i := range this.Sint32Map {
1129 if this.Sint32Map[i] != that1.Sint32Map[i] {
1130 return false
1131 }
1132 }
1133 if len(this.Sint64Map) != len(that1.Sint64Map) {
1134 return false
1135 }
1136 for i := range this.Sint64Map {
1137 if this.Sint64Map[i] != that1.Sint64Map[i] {
1138 return false
1139 }
1140 }
1141 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1142 return false
1143 }
1144 for i := range this.Fixed32Map {
1145 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1146 return false
1147 }
1148 }
1149 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1150 return false
1151 }
1152 for i := range this.Sfixed32Map {
1153 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1154 return false
1155 }
1156 }
1157 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1158 return false
1159 }
1160 for i := range this.Fixed64Map {
1161 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1162 return false
1163 }
1164 }
1165 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1166 return false
1167 }
1168 for i := range this.Sfixed64Map {
1169 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1170 return false
1171 }
1172 }
1173 if len(this.BoolMap) != len(that1.BoolMap) {
1174 return false
1175 }
1176 for i := range this.BoolMap {
1177 if this.BoolMap[i] != that1.BoolMap[i] {
1178 return false
1179 }
1180 }
1181 if len(this.StringMap) != len(that1.StringMap) {
1182 return false
1183 }
1184 for i := range this.StringMap {
1185 if this.StringMap[i] != that1.StringMap[i] {
1186 return false
1187 }
1188 }
1189 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1190 return false
1191 }
1192 for i := range this.StringToBytesMap {
1193 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1194 return false
1195 }
1196 }
1197 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1198 return false
1199 }
1200 for i := range this.StringToEnumMap {
1201 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1202 return false
1203 }
1204 }
1205 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1206 return false
1207 }
1208 for i := range this.StringToMsgMap {
1209 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1210 return false
1211 }
1212 }
1213 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1214 return false
1215 }
1216 return true
1217 }
1218 func (this *AllMapsOrdered) VerboseEqual(that interface{}) error {
1219 if that == nil {
1220 if this == nil {
1221 return nil
1222 }
1223 return fmt.Errorf("that == nil && this != nil")
1224 }
1225
1226 that1, ok := that.(*AllMapsOrdered)
1227 if !ok {
1228 that2, ok := that.(AllMapsOrdered)
1229 if ok {
1230 that1 = &that2
1231 } else {
1232 return fmt.Errorf("that is not of type *AllMapsOrdered")
1233 }
1234 }
1235 if that1 == nil {
1236 if this == nil {
1237 return nil
1238 }
1239 return fmt.Errorf("that is type *AllMapsOrdered but is nil && this != nil")
1240 } else if this == nil {
1241 return fmt.Errorf("that is type *AllMapsOrdered but is not nil && this == nil")
1242 }
1243 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1244 return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
1245 }
1246 for i := range this.StringToDoubleMap {
1247 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1248 return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
1249 }
1250 }
1251 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1252 return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
1253 }
1254 for i := range this.StringToFloatMap {
1255 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1256 return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
1257 }
1258 }
1259 if len(this.Int32Map) != len(that1.Int32Map) {
1260 return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
1261 }
1262 for i := range this.Int32Map {
1263 if this.Int32Map[i] != that1.Int32Map[i] {
1264 return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
1265 }
1266 }
1267 if len(this.Int64Map) != len(that1.Int64Map) {
1268 return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
1269 }
1270 for i := range this.Int64Map {
1271 if this.Int64Map[i] != that1.Int64Map[i] {
1272 return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
1273 }
1274 }
1275 if len(this.Uint32Map) != len(that1.Uint32Map) {
1276 return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
1277 }
1278 for i := range this.Uint32Map {
1279 if this.Uint32Map[i] != that1.Uint32Map[i] {
1280 return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
1281 }
1282 }
1283 if len(this.Uint64Map) != len(that1.Uint64Map) {
1284 return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
1285 }
1286 for i := range this.Uint64Map {
1287 if this.Uint64Map[i] != that1.Uint64Map[i] {
1288 return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
1289 }
1290 }
1291 if len(this.Sint32Map) != len(that1.Sint32Map) {
1292 return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
1293 }
1294 for i := range this.Sint32Map {
1295 if this.Sint32Map[i] != that1.Sint32Map[i] {
1296 return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
1297 }
1298 }
1299 if len(this.Sint64Map) != len(that1.Sint64Map) {
1300 return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
1301 }
1302 for i := range this.Sint64Map {
1303 if this.Sint64Map[i] != that1.Sint64Map[i] {
1304 return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
1305 }
1306 }
1307 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1308 return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
1309 }
1310 for i := range this.Fixed32Map {
1311 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1312 return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
1313 }
1314 }
1315 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1316 return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
1317 }
1318 for i := range this.Sfixed32Map {
1319 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1320 return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
1321 }
1322 }
1323 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1324 return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
1325 }
1326 for i := range this.Fixed64Map {
1327 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1328 return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
1329 }
1330 }
1331 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1332 return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
1333 }
1334 for i := range this.Sfixed64Map {
1335 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1336 return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
1337 }
1338 }
1339 if len(this.BoolMap) != len(that1.BoolMap) {
1340 return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
1341 }
1342 for i := range this.BoolMap {
1343 if this.BoolMap[i] != that1.BoolMap[i] {
1344 return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
1345 }
1346 }
1347 if len(this.StringMap) != len(that1.StringMap) {
1348 return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
1349 }
1350 for i := range this.StringMap {
1351 if this.StringMap[i] != that1.StringMap[i] {
1352 return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
1353 }
1354 }
1355 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1356 return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
1357 }
1358 for i := range this.StringToBytesMap {
1359 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1360 return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
1361 }
1362 }
1363 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1364 return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
1365 }
1366 for i := range this.StringToEnumMap {
1367 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1368 return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
1369 }
1370 }
1371 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1372 return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
1373 }
1374 for i := range this.StringToMsgMap {
1375 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1376 return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
1377 }
1378 }
1379 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1380 return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
1381 }
1382 return nil
1383 }
1384 func (this *AllMapsOrdered) Equal(that interface{}) bool {
1385 if that == nil {
1386 return this == nil
1387 }
1388
1389 that1, ok := that.(*AllMapsOrdered)
1390 if !ok {
1391 that2, ok := that.(AllMapsOrdered)
1392 if ok {
1393 that1 = &that2
1394 } else {
1395 return false
1396 }
1397 }
1398 if that1 == nil {
1399 return this == nil
1400 } else if this == nil {
1401 return false
1402 }
1403 if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
1404 return false
1405 }
1406 for i := range this.StringToDoubleMap {
1407 if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
1408 return false
1409 }
1410 }
1411 if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
1412 return false
1413 }
1414 for i := range this.StringToFloatMap {
1415 if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
1416 return false
1417 }
1418 }
1419 if len(this.Int32Map) != len(that1.Int32Map) {
1420 return false
1421 }
1422 for i := range this.Int32Map {
1423 if this.Int32Map[i] != that1.Int32Map[i] {
1424 return false
1425 }
1426 }
1427 if len(this.Int64Map) != len(that1.Int64Map) {
1428 return false
1429 }
1430 for i := range this.Int64Map {
1431 if this.Int64Map[i] != that1.Int64Map[i] {
1432 return false
1433 }
1434 }
1435 if len(this.Uint32Map) != len(that1.Uint32Map) {
1436 return false
1437 }
1438 for i := range this.Uint32Map {
1439 if this.Uint32Map[i] != that1.Uint32Map[i] {
1440 return false
1441 }
1442 }
1443 if len(this.Uint64Map) != len(that1.Uint64Map) {
1444 return false
1445 }
1446 for i := range this.Uint64Map {
1447 if this.Uint64Map[i] != that1.Uint64Map[i] {
1448 return false
1449 }
1450 }
1451 if len(this.Sint32Map) != len(that1.Sint32Map) {
1452 return false
1453 }
1454 for i := range this.Sint32Map {
1455 if this.Sint32Map[i] != that1.Sint32Map[i] {
1456 return false
1457 }
1458 }
1459 if len(this.Sint64Map) != len(that1.Sint64Map) {
1460 return false
1461 }
1462 for i := range this.Sint64Map {
1463 if this.Sint64Map[i] != that1.Sint64Map[i] {
1464 return false
1465 }
1466 }
1467 if len(this.Fixed32Map) != len(that1.Fixed32Map) {
1468 return false
1469 }
1470 for i := range this.Fixed32Map {
1471 if this.Fixed32Map[i] != that1.Fixed32Map[i] {
1472 return false
1473 }
1474 }
1475 if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
1476 return false
1477 }
1478 for i := range this.Sfixed32Map {
1479 if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
1480 return false
1481 }
1482 }
1483 if len(this.Fixed64Map) != len(that1.Fixed64Map) {
1484 return false
1485 }
1486 for i := range this.Fixed64Map {
1487 if this.Fixed64Map[i] != that1.Fixed64Map[i] {
1488 return false
1489 }
1490 }
1491 if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
1492 return false
1493 }
1494 for i := range this.Sfixed64Map {
1495 if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
1496 return false
1497 }
1498 }
1499 if len(this.BoolMap) != len(that1.BoolMap) {
1500 return false
1501 }
1502 for i := range this.BoolMap {
1503 if this.BoolMap[i] != that1.BoolMap[i] {
1504 return false
1505 }
1506 }
1507 if len(this.StringMap) != len(that1.StringMap) {
1508 return false
1509 }
1510 for i := range this.StringMap {
1511 if this.StringMap[i] != that1.StringMap[i] {
1512 return false
1513 }
1514 }
1515 if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
1516 return false
1517 }
1518 for i := range this.StringToBytesMap {
1519 if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
1520 return false
1521 }
1522 }
1523 if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
1524 return false
1525 }
1526 for i := range this.StringToEnumMap {
1527 if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
1528 return false
1529 }
1530 }
1531 if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
1532 return false
1533 }
1534 for i := range this.StringToMsgMap {
1535 if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
1536 return false
1537 }
1538 }
1539 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
1540 return false
1541 }
1542 return true
1543 }
1544
1545 type FloatingPointFace interface {
1546 Proto() github_com_gogo_protobuf_proto.Message
1547 GetF() *float64
1548 }
1549
1550 func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message {
1551 return this
1552 }
1553
1554 func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message {
1555 return NewFloatingPointFromFace(this)
1556 }
1557
1558 func (this *FloatingPoint) GetF() *float64 {
1559 return this.F
1560 }
1561
1562 func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint {
1563 this := &FloatingPoint{}
1564 this.F = that.GetF()
1565 return this
1566 }
1567
1568 type CustomMapFace interface {
1569 Proto() github_com_gogo_protobuf_proto.Message
1570 GetNullable128S() map[string]*github_com_gogo_protobuf_test_custom.Uint128
1571 GetUint128S() map[string]github_com_gogo_protobuf_test_custom.Uint128
1572 GetNullableIds() map[string]*github_com_gogo_protobuf_test.Uuid
1573 GetIds() map[string]github_com_gogo_protobuf_test.Uuid
1574 }
1575
1576 func (this *CustomMap) Proto() github_com_gogo_protobuf_proto.Message {
1577 return this
1578 }
1579
1580 func (this *CustomMap) TestProto() github_com_gogo_protobuf_proto.Message {
1581 return NewCustomMapFromFace(this)
1582 }
1583
1584 func (this *CustomMap) GetNullable128S() map[string]*github_com_gogo_protobuf_test_custom.Uint128 {
1585 return this.Nullable128S
1586 }
1587
1588 func (this *CustomMap) GetUint128S() map[string]github_com_gogo_protobuf_test_custom.Uint128 {
1589 return this.Uint128S
1590 }
1591
1592 func (this *CustomMap) GetNullableIds() map[string]*github_com_gogo_protobuf_test.Uuid {
1593 return this.NullableIds
1594 }
1595
1596 func (this *CustomMap) GetIds() map[string]github_com_gogo_protobuf_test.Uuid {
1597 return this.Ids
1598 }
1599
1600 func NewCustomMapFromFace(that CustomMapFace) *CustomMap {
1601 this := &CustomMap{}
1602 this.Nullable128S = that.GetNullable128S()
1603 this.Uint128S = that.GetUint128S()
1604 this.NullableIds = that.GetNullableIds()
1605 this.Ids = that.GetIds()
1606 return this
1607 }
1608
1609 type AllMapsFace interface {
1610 Proto() github_com_gogo_protobuf_proto.Message
1611 GetStringToDoubleMap() map[string]float64
1612 GetStringToFloatMap() map[string]float32
1613 GetInt32Map() map[int32]int32
1614 GetInt64Map() map[int64]int64
1615 GetUint32Map() map[uint32]uint32
1616 GetUint64Map() map[uint64]uint64
1617 GetSint32Map() map[int32]int32
1618 GetSint64Map() map[int64]int64
1619 GetFixed32Map() map[uint32]uint32
1620 GetSfixed32Map() map[int32]int32
1621 GetFixed64Map() map[uint64]uint64
1622 GetSfixed64Map() map[int64]int64
1623 GetBoolMap() map[bool]bool
1624 GetStringMap() map[string]string
1625 GetStringToBytesMap() map[string][]byte
1626 GetStringToEnumMap() map[string]MapEnum
1627 GetStringToMsgMap() map[string]*FloatingPoint
1628 }
1629
1630 func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message {
1631 return this
1632 }
1633
1634 func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message {
1635 return NewAllMapsFromFace(this)
1636 }
1637
1638 func (this *AllMaps) GetStringToDoubleMap() map[string]float64 {
1639 return this.StringToDoubleMap
1640 }
1641
1642 func (this *AllMaps) GetStringToFloatMap() map[string]float32 {
1643 return this.StringToFloatMap
1644 }
1645
1646 func (this *AllMaps) GetInt32Map() map[int32]int32 {
1647 return this.Int32Map
1648 }
1649
1650 func (this *AllMaps) GetInt64Map() map[int64]int64 {
1651 return this.Int64Map
1652 }
1653
1654 func (this *AllMaps) GetUint32Map() map[uint32]uint32 {
1655 return this.Uint32Map
1656 }
1657
1658 func (this *AllMaps) GetUint64Map() map[uint64]uint64 {
1659 return this.Uint64Map
1660 }
1661
1662 func (this *AllMaps) GetSint32Map() map[int32]int32 {
1663 return this.Sint32Map
1664 }
1665
1666 func (this *AllMaps) GetSint64Map() map[int64]int64 {
1667 return this.Sint64Map
1668 }
1669
1670 func (this *AllMaps) GetFixed32Map() map[uint32]uint32 {
1671 return this.Fixed32Map
1672 }
1673
1674 func (this *AllMaps) GetSfixed32Map() map[int32]int32 {
1675 return this.Sfixed32Map
1676 }
1677
1678 func (this *AllMaps) GetFixed64Map() map[uint64]uint64 {
1679 return this.Fixed64Map
1680 }
1681
1682 func (this *AllMaps) GetSfixed64Map() map[int64]int64 {
1683 return this.Sfixed64Map
1684 }
1685
1686 func (this *AllMaps) GetBoolMap() map[bool]bool {
1687 return this.BoolMap
1688 }
1689
1690 func (this *AllMaps) GetStringMap() map[string]string {
1691 return this.StringMap
1692 }
1693
1694 func (this *AllMaps) GetStringToBytesMap() map[string][]byte {
1695 return this.StringToBytesMap
1696 }
1697
1698 func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum {
1699 return this.StringToEnumMap
1700 }
1701
1702 func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint {
1703 return this.StringToMsgMap
1704 }
1705
1706 func NewAllMapsFromFace(that AllMapsFace) *AllMaps {
1707 this := &AllMaps{}
1708 this.StringToDoubleMap = that.GetStringToDoubleMap()
1709 this.StringToFloatMap = that.GetStringToFloatMap()
1710 this.Int32Map = that.GetInt32Map()
1711 this.Int64Map = that.GetInt64Map()
1712 this.Uint32Map = that.GetUint32Map()
1713 this.Uint64Map = that.GetUint64Map()
1714 this.Sint32Map = that.GetSint32Map()
1715 this.Sint64Map = that.GetSint64Map()
1716 this.Fixed32Map = that.GetFixed32Map()
1717 this.Sfixed32Map = that.GetSfixed32Map()
1718 this.Fixed64Map = that.GetFixed64Map()
1719 this.Sfixed64Map = that.GetSfixed64Map()
1720 this.BoolMap = that.GetBoolMap()
1721 this.StringMap = that.GetStringMap()
1722 this.StringToBytesMap = that.GetStringToBytesMap()
1723 this.StringToEnumMap = that.GetStringToEnumMap()
1724 this.StringToMsgMap = that.GetStringToMsgMap()
1725 return this
1726 }
1727
1728 type AllMapsOrderedFace interface {
1729 Proto() github_com_gogo_protobuf_proto.Message
1730 GetStringToDoubleMap() map[string]float64
1731 GetStringToFloatMap() map[string]float32
1732 GetInt32Map() map[int32]int32
1733 GetInt64Map() map[int64]int64
1734 GetUint32Map() map[uint32]uint32
1735 GetUint64Map() map[uint64]uint64
1736 GetSint32Map() map[int32]int32
1737 GetSint64Map() map[int64]int64
1738 GetFixed32Map() map[uint32]uint32
1739 GetSfixed32Map() map[int32]int32
1740 GetFixed64Map() map[uint64]uint64
1741 GetSfixed64Map() map[int64]int64
1742 GetBoolMap() map[bool]bool
1743 GetStringMap() map[string]string
1744 GetStringToBytesMap() map[string][]byte
1745 GetStringToEnumMap() map[string]MapEnum
1746 GetStringToMsgMap() map[string]*FloatingPoint
1747 }
1748
1749 func (this *AllMapsOrdered) Proto() github_com_gogo_protobuf_proto.Message {
1750 return this
1751 }
1752
1753 func (this *AllMapsOrdered) TestProto() github_com_gogo_protobuf_proto.Message {
1754 return NewAllMapsOrderedFromFace(this)
1755 }
1756
1757 func (this *AllMapsOrdered) GetStringToDoubleMap() map[string]float64 {
1758 return this.StringToDoubleMap
1759 }
1760
1761 func (this *AllMapsOrdered) GetStringToFloatMap() map[string]float32 {
1762 return this.StringToFloatMap
1763 }
1764
1765 func (this *AllMapsOrdered) GetInt32Map() map[int32]int32 {
1766 return this.Int32Map
1767 }
1768
1769 func (this *AllMapsOrdered) GetInt64Map() map[int64]int64 {
1770 return this.Int64Map
1771 }
1772
1773 func (this *AllMapsOrdered) GetUint32Map() map[uint32]uint32 {
1774 return this.Uint32Map
1775 }
1776
1777 func (this *AllMapsOrdered) GetUint64Map() map[uint64]uint64 {
1778 return this.Uint64Map
1779 }
1780
1781 func (this *AllMapsOrdered) GetSint32Map() map[int32]int32 {
1782 return this.Sint32Map
1783 }
1784
1785 func (this *AllMapsOrdered) GetSint64Map() map[int64]int64 {
1786 return this.Sint64Map
1787 }
1788
1789 func (this *AllMapsOrdered) GetFixed32Map() map[uint32]uint32 {
1790 return this.Fixed32Map
1791 }
1792
1793 func (this *AllMapsOrdered) GetSfixed32Map() map[int32]int32 {
1794 return this.Sfixed32Map
1795 }
1796
1797 func (this *AllMapsOrdered) GetFixed64Map() map[uint64]uint64 {
1798 return this.Fixed64Map
1799 }
1800
1801 func (this *AllMapsOrdered) GetSfixed64Map() map[int64]int64 {
1802 return this.Sfixed64Map
1803 }
1804
1805 func (this *AllMapsOrdered) GetBoolMap() map[bool]bool {
1806 return this.BoolMap
1807 }
1808
1809 func (this *AllMapsOrdered) GetStringMap() map[string]string {
1810 return this.StringMap
1811 }
1812
1813 func (this *AllMapsOrdered) GetStringToBytesMap() map[string][]byte {
1814 return this.StringToBytesMap
1815 }
1816
1817 func (this *AllMapsOrdered) GetStringToEnumMap() map[string]MapEnum {
1818 return this.StringToEnumMap
1819 }
1820
1821 func (this *AllMapsOrdered) GetStringToMsgMap() map[string]*FloatingPoint {
1822 return this.StringToMsgMap
1823 }
1824
1825 func NewAllMapsOrderedFromFace(that AllMapsOrderedFace) *AllMapsOrdered {
1826 this := &AllMapsOrdered{}
1827 this.StringToDoubleMap = that.GetStringToDoubleMap()
1828 this.StringToFloatMap = that.GetStringToFloatMap()
1829 this.Int32Map = that.GetInt32Map()
1830 this.Int64Map = that.GetInt64Map()
1831 this.Uint32Map = that.GetUint32Map()
1832 this.Uint64Map = that.GetUint64Map()
1833 this.Sint32Map = that.GetSint32Map()
1834 this.Sint64Map = that.GetSint64Map()
1835 this.Fixed32Map = that.GetFixed32Map()
1836 this.Sfixed32Map = that.GetSfixed32Map()
1837 this.Fixed64Map = that.GetFixed64Map()
1838 this.Sfixed64Map = that.GetSfixed64Map()
1839 this.BoolMap = that.GetBoolMap()
1840 this.StringMap = that.GetStringMap()
1841 this.StringToBytesMap = that.GetStringToBytesMap()
1842 this.StringToEnumMap = that.GetStringToEnumMap()
1843 this.StringToMsgMap = that.GetStringToMsgMap()
1844 return this
1845 }
1846
1847 func (this *FloatingPoint) GoString() string {
1848 if this == nil {
1849 return "nil"
1850 }
1851 s := make([]string, 0, 5)
1852 s = append(s, "&proto2_maps.FloatingPoint{")
1853 if this.F != nil {
1854 s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n")
1855 }
1856 if this.XXX_unrecognized != nil {
1857 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1858 }
1859 s = append(s, "}")
1860 return strings.Join(s, "")
1861 }
1862 func (this *CustomMap) GoString() string {
1863 if this == nil {
1864 return "nil"
1865 }
1866 s := make([]string, 0, 8)
1867 s = append(s, "&proto2_maps.CustomMap{")
1868 keysForNullable128S := make([]string, 0, len(this.Nullable128S))
1869 for k := range this.Nullable128S {
1870 keysForNullable128S = append(keysForNullable128S, k)
1871 }
1872 github_com_gogo_protobuf_sortkeys.Strings(keysForNullable128S)
1873 mapStringForNullable128S := "map[string]*github_com_gogo_protobuf_test_custom.Uint128{"
1874 for _, k := range keysForNullable128S {
1875 mapStringForNullable128S += fmt.Sprintf("%#v: %#v,", k, this.Nullable128S[k])
1876 }
1877 mapStringForNullable128S += "}"
1878 if this.Nullable128S != nil {
1879 s = append(s, "Nullable128S: "+mapStringForNullable128S+",\n")
1880 }
1881 keysForUint128S := make([]string, 0, len(this.Uint128S))
1882 for k := range this.Uint128S {
1883 keysForUint128S = append(keysForUint128S, k)
1884 }
1885 github_com_gogo_protobuf_sortkeys.Strings(keysForUint128S)
1886 mapStringForUint128S := "map[string]github_com_gogo_protobuf_test_custom.Uint128{"
1887 for _, k := range keysForUint128S {
1888 mapStringForUint128S += fmt.Sprintf("%#v: %#v,", k, this.Uint128S[k])
1889 }
1890 mapStringForUint128S += "}"
1891 if this.Uint128S != nil {
1892 s = append(s, "Uint128S: "+mapStringForUint128S+",\n")
1893 }
1894 keysForNullableIds := make([]string, 0, len(this.NullableIds))
1895 for k := range this.NullableIds {
1896 keysForNullableIds = append(keysForNullableIds, k)
1897 }
1898 github_com_gogo_protobuf_sortkeys.Strings(keysForNullableIds)
1899 mapStringForNullableIds := "map[string]*github_com_gogo_protobuf_test.Uuid{"
1900 for _, k := range keysForNullableIds {
1901 mapStringForNullableIds += fmt.Sprintf("%#v: %#v,", k, this.NullableIds[k])
1902 }
1903 mapStringForNullableIds += "}"
1904 if this.NullableIds != nil {
1905 s = append(s, "NullableIds: "+mapStringForNullableIds+",\n")
1906 }
1907 keysForIds := make([]string, 0, len(this.Ids))
1908 for k := range this.Ids {
1909 keysForIds = append(keysForIds, k)
1910 }
1911 github_com_gogo_protobuf_sortkeys.Strings(keysForIds)
1912 mapStringForIds := "map[string]github_com_gogo_protobuf_test.Uuid{"
1913 for _, k := range keysForIds {
1914 mapStringForIds += fmt.Sprintf("%#v: %#v,", k, this.Ids[k])
1915 }
1916 mapStringForIds += "}"
1917 if this.Ids != nil {
1918 s = append(s, "Ids: "+mapStringForIds+",\n")
1919 }
1920 if this.XXX_unrecognized != nil {
1921 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
1922 }
1923 s = append(s, "}")
1924 return strings.Join(s, "")
1925 }
1926 func (this *AllMaps) GoString() string {
1927 if this == nil {
1928 return "nil"
1929 }
1930 s := make([]string, 0, 21)
1931 s = append(s, "&proto2_maps.AllMaps{")
1932 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
1933 for k := range this.StringToDoubleMap {
1934 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
1935 }
1936 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
1937 mapStringForStringToDoubleMap := "map[string]float64{"
1938 for _, k := range keysForStringToDoubleMap {
1939 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
1940 }
1941 mapStringForStringToDoubleMap += "}"
1942 if this.StringToDoubleMap != nil {
1943 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
1944 }
1945 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
1946 for k := range this.StringToFloatMap {
1947 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
1948 }
1949 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
1950 mapStringForStringToFloatMap := "map[string]float32{"
1951 for _, k := range keysForStringToFloatMap {
1952 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
1953 }
1954 mapStringForStringToFloatMap += "}"
1955 if this.StringToFloatMap != nil {
1956 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
1957 }
1958 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
1959 for k := range this.Int32Map {
1960 keysForInt32Map = append(keysForInt32Map, k)
1961 }
1962 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
1963 mapStringForInt32Map := "map[int32]int32{"
1964 for _, k := range keysForInt32Map {
1965 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
1966 }
1967 mapStringForInt32Map += "}"
1968 if this.Int32Map != nil {
1969 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
1970 }
1971 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
1972 for k := range this.Int64Map {
1973 keysForInt64Map = append(keysForInt64Map, k)
1974 }
1975 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
1976 mapStringForInt64Map := "map[int64]int64{"
1977 for _, k := range keysForInt64Map {
1978 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
1979 }
1980 mapStringForInt64Map += "}"
1981 if this.Int64Map != nil {
1982 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
1983 }
1984 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
1985 for k := range this.Uint32Map {
1986 keysForUint32Map = append(keysForUint32Map, k)
1987 }
1988 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
1989 mapStringForUint32Map := "map[uint32]uint32{"
1990 for _, k := range keysForUint32Map {
1991 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
1992 }
1993 mapStringForUint32Map += "}"
1994 if this.Uint32Map != nil {
1995 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
1996 }
1997 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
1998 for k := range this.Uint64Map {
1999 keysForUint64Map = append(keysForUint64Map, k)
2000 }
2001 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
2002 mapStringForUint64Map := "map[uint64]uint64{"
2003 for _, k := range keysForUint64Map {
2004 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
2005 }
2006 mapStringForUint64Map += "}"
2007 if this.Uint64Map != nil {
2008 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
2009 }
2010 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
2011 for k := range this.Sint32Map {
2012 keysForSint32Map = append(keysForSint32Map, k)
2013 }
2014 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
2015 mapStringForSint32Map := "map[int32]int32{"
2016 for _, k := range keysForSint32Map {
2017 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
2018 }
2019 mapStringForSint32Map += "}"
2020 if this.Sint32Map != nil {
2021 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
2022 }
2023 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
2024 for k := range this.Sint64Map {
2025 keysForSint64Map = append(keysForSint64Map, k)
2026 }
2027 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
2028 mapStringForSint64Map := "map[int64]int64{"
2029 for _, k := range keysForSint64Map {
2030 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
2031 }
2032 mapStringForSint64Map += "}"
2033 if this.Sint64Map != nil {
2034 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
2035 }
2036 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
2037 for k := range this.Fixed32Map {
2038 keysForFixed32Map = append(keysForFixed32Map, k)
2039 }
2040 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
2041 mapStringForFixed32Map := "map[uint32]uint32{"
2042 for _, k := range keysForFixed32Map {
2043 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
2044 }
2045 mapStringForFixed32Map += "}"
2046 if this.Fixed32Map != nil {
2047 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
2048 }
2049 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
2050 for k := range this.Sfixed32Map {
2051 keysForSfixed32Map = append(keysForSfixed32Map, k)
2052 }
2053 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
2054 mapStringForSfixed32Map := "map[int32]int32{"
2055 for _, k := range keysForSfixed32Map {
2056 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
2057 }
2058 mapStringForSfixed32Map += "}"
2059 if this.Sfixed32Map != nil {
2060 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
2061 }
2062 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
2063 for k := range this.Fixed64Map {
2064 keysForFixed64Map = append(keysForFixed64Map, k)
2065 }
2066 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
2067 mapStringForFixed64Map := "map[uint64]uint64{"
2068 for _, k := range keysForFixed64Map {
2069 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
2070 }
2071 mapStringForFixed64Map += "}"
2072 if this.Fixed64Map != nil {
2073 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
2074 }
2075 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
2076 for k := range this.Sfixed64Map {
2077 keysForSfixed64Map = append(keysForSfixed64Map, k)
2078 }
2079 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
2080 mapStringForSfixed64Map := "map[int64]int64{"
2081 for _, k := range keysForSfixed64Map {
2082 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
2083 }
2084 mapStringForSfixed64Map += "}"
2085 if this.Sfixed64Map != nil {
2086 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
2087 }
2088 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
2089 for k := range this.BoolMap {
2090 keysForBoolMap = append(keysForBoolMap, k)
2091 }
2092 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
2093 mapStringForBoolMap := "map[bool]bool{"
2094 for _, k := range keysForBoolMap {
2095 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
2096 }
2097 mapStringForBoolMap += "}"
2098 if this.BoolMap != nil {
2099 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
2100 }
2101 keysForStringMap := make([]string, 0, len(this.StringMap))
2102 for k := range this.StringMap {
2103 keysForStringMap = append(keysForStringMap, k)
2104 }
2105 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
2106 mapStringForStringMap := "map[string]string{"
2107 for _, k := range keysForStringMap {
2108 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
2109 }
2110 mapStringForStringMap += "}"
2111 if this.StringMap != nil {
2112 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
2113 }
2114 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
2115 for k := range this.StringToBytesMap {
2116 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
2117 }
2118 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
2119 mapStringForStringToBytesMap := "map[string][]byte{"
2120 for _, k := range keysForStringToBytesMap {
2121 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
2122 }
2123 mapStringForStringToBytesMap += "}"
2124 if this.StringToBytesMap != nil {
2125 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
2126 }
2127 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
2128 for k := range this.StringToEnumMap {
2129 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
2130 }
2131 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
2132 mapStringForStringToEnumMap := "map[string]MapEnum{"
2133 for _, k := range keysForStringToEnumMap {
2134 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
2135 }
2136 mapStringForStringToEnumMap += "}"
2137 if this.StringToEnumMap != nil {
2138 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
2139 }
2140 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
2141 for k := range this.StringToMsgMap {
2142 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
2143 }
2144 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
2145 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
2146 for _, k := range keysForStringToMsgMap {
2147 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
2148 }
2149 mapStringForStringToMsgMap += "}"
2150 if this.StringToMsgMap != nil {
2151 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
2152 }
2153 if this.XXX_unrecognized != nil {
2154 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2155 }
2156 s = append(s, "}")
2157 return strings.Join(s, "")
2158 }
2159 func (this *AllMapsOrdered) GoString() string {
2160 if this == nil {
2161 return "nil"
2162 }
2163 s := make([]string, 0, 21)
2164 s = append(s, "&proto2_maps.AllMapsOrdered{")
2165 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
2166 for k := range this.StringToDoubleMap {
2167 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
2168 }
2169 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
2170 mapStringForStringToDoubleMap := "map[string]float64{"
2171 for _, k := range keysForStringToDoubleMap {
2172 mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
2173 }
2174 mapStringForStringToDoubleMap += "}"
2175 if this.StringToDoubleMap != nil {
2176 s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
2177 }
2178 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
2179 for k := range this.StringToFloatMap {
2180 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
2181 }
2182 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
2183 mapStringForStringToFloatMap := "map[string]float32{"
2184 for _, k := range keysForStringToFloatMap {
2185 mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
2186 }
2187 mapStringForStringToFloatMap += "}"
2188 if this.StringToFloatMap != nil {
2189 s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
2190 }
2191 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
2192 for k := range this.Int32Map {
2193 keysForInt32Map = append(keysForInt32Map, k)
2194 }
2195 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
2196 mapStringForInt32Map := "map[int32]int32{"
2197 for _, k := range keysForInt32Map {
2198 mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
2199 }
2200 mapStringForInt32Map += "}"
2201 if this.Int32Map != nil {
2202 s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
2203 }
2204 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
2205 for k := range this.Int64Map {
2206 keysForInt64Map = append(keysForInt64Map, k)
2207 }
2208 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
2209 mapStringForInt64Map := "map[int64]int64{"
2210 for _, k := range keysForInt64Map {
2211 mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
2212 }
2213 mapStringForInt64Map += "}"
2214 if this.Int64Map != nil {
2215 s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
2216 }
2217 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
2218 for k := range this.Uint32Map {
2219 keysForUint32Map = append(keysForUint32Map, k)
2220 }
2221 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
2222 mapStringForUint32Map := "map[uint32]uint32{"
2223 for _, k := range keysForUint32Map {
2224 mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
2225 }
2226 mapStringForUint32Map += "}"
2227 if this.Uint32Map != nil {
2228 s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
2229 }
2230 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
2231 for k := range this.Uint64Map {
2232 keysForUint64Map = append(keysForUint64Map, k)
2233 }
2234 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
2235 mapStringForUint64Map := "map[uint64]uint64{"
2236 for _, k := range keysForUint64Map {
2237 mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
2238 }
2239 mapStringForUint64Map += "}"
2240 if this.Uint64Map != nil {
2241 s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
2242 }
2243 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
2244 for k := range this.Sint32Map {
2245 keysForSint32Map = append(keysForSint32Map, k)
2246 }
2247 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
2248 mapStringForSint32Map := "map[int32]int32{"
2249 for _, k := range keysForSint32Map {
2250 mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
2251 }
2252 mapStringForSint32Map += "}"
2253 if this.Sint32Map != nil {
2254 s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
2255 }
2256 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
2257 for k := range this.Sint64Map {
2258 keysForSint64Map = append(keysForSint64Map, k)
2259 }
2260 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
2261 mapStringForSint64Map := "map[int64]int64{"
2262 for _, k := range keysForSint64Map {
2263 mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
2264 }
2265 mapStringForSint64Map += "}"
2266 if this.Sint64Map != nil {
2267 s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
2268 }
2269 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
2270 for k := range this.Fixed32Map {
2271 keysForFixed32Map = append(keysForFixed32Map, k)
2272 }
2273 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
2274 mapStringForFixed32Map := "map[uint32]uint32{"
2275 for _, k := range keysForFixed32Map {
2276 mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
2277 }
2278 mapStringForFixed32Map += "}"
2279 if this.Fixed32Map != nil {
2280 s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
2281 }
2282 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
2283 for k := range this.Sfixed32Map {
2284 keysForSfixed32Map = append(keysForSfixed32Map, k)
2285 }
2286 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
2287 mapStringForSfixed32Map := "map[int32]int32{"
2288 for _, k := range keysForSfixed32Map {
2289 mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
2290 }
2291 mapStringForSfixed32Map += "}"
2292 if this.Sfixed32Map != nil {
2293 s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
2294 }
2295 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
2296 for k := range this.Fixed64Map {
2297 keysForFixed64Map = append(keysForFixed64Map, k)
2298 }
2299 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
2300 mapStringForFixed64Map := "map[uint64]uint64{"
2301 for _, k := range keysForFixed64Map {
2302 mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
2303 }
2304 mapStringForFixed64Map += "}"
2305 if this.Fixed64Map != nil {
2306 s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
2307 }
2308 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
2309 for k := range this.Sfixed64Map {
2310 keysForSfixed64Map = append(keysForSfixed64Map, k)
2311 }
2312 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
2313 mapStringForSfixed64Map := "map[int64]int64{"
2314 for _, k := range keysForSfixed64Map {
2315 mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
2316 }
2317 mapStringForSfixed64Map += "}"
2318 if this.Sfixed64Map != nil {
2319 s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
2320 }
2321 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
2322 for k := range this.BoolMap {
2323 keysForBoolMap = append(keysForBoolMap, k)
2324 }
2325 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
2326 mapStringForBoolMap := "map[bool]bool{"
2327 for _, k := range keysForBoolMap {
2328 mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
2329 }
2330 mapStringForBoolMap += "}"
2331 if this.BoolMap != nil {
2332 s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
2333 }
2334 keysForStringMap := make([]string, 0, len(this.StringMap))
2335 for k := range this.StringMap {
2336 keysForStringMap = append(keysForStringMap, k)
2337 }
2338 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
2339 mapStringForStringMap := "map[string]string{"
2340 for _, k := range keysForStringMap {
2341 mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
2342 }
2343 mapStringForStringMap += "}"
2344 if this.StringMap != nil {
2345 s = append(s, "StringMap: "+mapStringForStringMap+",\n")
2346 }
2347 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
2348 for k := range this.StringToBytesMap {
2349 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
2350 }
2351 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
2352 mapStringForStringToBytesMap := "map[string][]byte{"
2353 for _, k := range keysForStringToBytesMap {
2354 mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
2355 }
2356 mapStringForStringToBytesMap += "}"
2357 if this.StringToBytesMap != nil {
2358 s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
2359 }
2360 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
2361 for k := range this.StringToEnumMap {
2362 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
2363 }
2364 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
2365 mapStringForStringToEnumMap := "map[string]MapEnum{"
2366 for _, k := range keysForStringToEnumMap {
2367 mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
2368 }
2369 mapStringForStringToEnumMap += "}"
2370 if this.StringToEnumMap != nil {
2371 s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
2372 }
2373 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
2374 for k := range this.StringToMsgMap {
2375 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
2376 }
2377 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
2378 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
2379 for _, k := range keysForStringToMsgMap {
2380 mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
2381 }
2382 mapStringForStringToMsgMap += "}"
2383 if this.StringToMsgMap != nil {
2384 s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
2385 }
2386 if this.XXX_unrecognized != nil {
2387 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
2388 }
2389 s = append(s, "}")
2390 return strings.Join(s, "")
2391 }
2392 func valueToGoStringMapsproto2(v interface{}, typ string) string {
2393 rv := reflect.ValueOf(v)
2394 if rv.IsNil() {
2395 return "nil"
2396 }
2397 pv := reflect.Indirect(rv).Interface()
2398 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
2399 }
2400 func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint {
2401 this := &FloatingPoint{}
2402 if r.Intn(5) != 0 {
2403 v1 := float64(r.Float64())
2404 if r.Intn(2) == 0 {
2405 v1 *= -1
2406 }
2407 this.F = &v1
2408 }
2409 if !easy && r.Intn(10) != 0 {
2410 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2)
2411 }
2412 return this
2413 }
2414
2415 func NewPopulatedCustomMap(r randyMapsproto2, easy bool) *CustomMap {
2416 this := &CustomMap{}
2417 if r.Intn(5) != 0 {
2418 v2 := r.Intn(10)
2419 this.Nullable128S = make(map[string]*github_com_gogo_protobuf_test_custom.Uint128)
2420 for i := 0; i < v2; i++ {
2421 this.Nullable128S[randStringMapsproto2(r)] = (*github_com_gogo_protobuf_test_custom.Uint128)(github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r))
2422 }
2423 }
2424 if r.Intn(5) != 0 {
2425 v3 := r.Intn(10)
2426 this.Uint128S = make(map[string]github_com_gogo_protobuf_test_custom.Uint128)
2427 for i := 0; i < v3; i++ {
2428 this.Uint128S[randStringMapsproto2(r)] = (github_com_gogo_protobuf_test_custom.Uint128)(*github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r))
2429 }
2430 }
2431 if r.Intn(5) != 0 {
2432 v4 := r.Intn(10)
2433 this.NullableIds = make(map[string]*github_com_gogo_protobuf_test.Uuid)
2434 for i := 0; i < v4; i++ {
2435 this.NullableIds[randStringMapsproto2(r)] = (*github_com_gogo_protobuf_test.Uuid)(github_com_gogo_protobuf_test.NewPopulatedUuid(r))
2436 }
2437 }
2438 if r.Intn(5) != 0 {
2439 v5 := r.Intn(10)
2440 this.Ids = make(map[string]github_com_gogo_protobuf_test.Uuid)
2441 for i := 0; i < v5; i++ {
2442 this.Ids[randStringMapsproto2(r)] = (github_com_gogo_protobuf_test.Uuid)(*github_com_gogo_protobuf_test.NewPopulatedUuid(r))
2443 }
2444 }
2445 if !easy && r.Intn(10) != 0 {
2446 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 5)
2447 }
2448 return this
2449 }
2450
2451 func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps {
2452 this := &AllMaps{}
2453 if r.Intn(5) != 0 {
2454 v6 := r.Intn(10)
2455 this.StringToDoubleMap = make(map[string]float64)
2456 for i := 0; i < v6; i++ {
2457 v7 := randStringMapsproto2(r)
2458 this.StringToDoubleMap[v7] = float64(r.Float64())
2459 if r.Intn(2) == 0 {
2460 this.StringToDoubleMap[v7] *= -1
2461 }
2462 }
2463 }
2464 if r.Intn(5) != 0 {
2465 v8 := r.Intn(10)
2466 this.StringToFloatMap = make(map[string]float32)
2467 for i := 0; i < v8; i++ {
2468 v9 := randStringMapsproto2(r)
2469 this.StringToFloatMap[v9] = float32(r.Float32())
2470 if r.Intn(2) == 0 {
2471 this.StringToFloatMap[v9] *= -1
2472 }
2473 }
2474 }
2475 if r.Intn(5) != 0 {
2476 v10 := r.Intn(10)
2477 this.Int32Map = make(map[int32]int32)
2478 for i := 0; i < v10; i++ {
2479 v11 := int32(r.Int31())
2480 this.Int32Map[v11] = int32(r.Int31())
2481 if r.Intn(2) == 0 {
2482 this.Int32Map[v11] *= -1
2483 }
2484 }
2485 }
2486 if r.Intn(5) != 0 {
2487 v12 := r.Intn(10)
2488 this.Int64Map = make(map[int64]int64)
2489 for i := 0; i < v12; i++ {
2490 v13 := int64(r.Int63())
2491 this.Int64Map[v13] = int64(r.Int63())
2492 if r.Intn(2) == 0 {
2493 this.Int64Map[v13] *= -1
2494 }
2495 }
2496 }
2497 if r.Intn(5) != 0 {
2498 v14 := r.Intn(10)
2499 this.Uint32Map = make(map[uint32]uint32)
2500 for i := 0; i < v14; i++ {
2501 v15 := uint32(r.Uint32())
2502 this.Uint32Map[v15] = uint32(r.Uint32())
2503 }
2504 }
2505 if r.Intn(5) != 0 {
2506 v16 := r.Intn(10)
2507 this.Uint64Map = make(map[uint64]uint64)
2508 for i := 0; i < v16; i++ {
2509 v17 := uint64(uint64(r.Uint32()))
2510 this.Uint64Map[v17] = uint64(uint64(r.Uint32()))
2511 }
2512 }
2513 if r.Intn(5) != 0 {
2514 v18 := r.Intn(10)
2515 this.Sint32Map = make(map[int32]int32)
2516 for i := 0; i < v18; i++ {
2517 v19 := int32(r.Int31())
2518 this.Sint32Map[v19] = int32(r.Int31())
2519 if r.Intn(2) == 0 {
2520 this.Sint32Map[v19] *= -1
2521 }
2522 }
2523 }
2524 if r.Intn(5) != 0 {
2525 v20 := r.Intn(10)
2526 this.Sint64Map = make(map[int64]int64)
2527 for i := 0; i < v20; i++ {
2528 v21 := int64(r.Int63())
2529 this.Sint64Map[v21] = int64(r.Int63())
2530 if r.Intn(2) == 0 {
2531 this.Sint64Map[v21] *= -1
2532 }
2533 }
2534 }
2535 if r.Intn(5) != 0 {
2536 v22 := r.Intn(10)
2537 this.Fixed32Map = make(map[uint32]uint32)
2538 for i := 0; i < v22; i++ {
2539 v23 := uint32(r.Uint32())
2540 this.Fixed32Map[v23] = uint32(r.Uint32())
2541 }
2542 }
2543 if r.Intn(5) != 0 {
2544 v24 := r.Intn(10)
2545 this.Sfixed32Map = make(map[int32]int32)
2546 for i := 0; i < v24; i++ {
2547 v25 := int32(r.Int31())
2548 this.Sfixed32Map[v25] = int32(r.Int31())
2549 if r.Intn(2) == 0 {
2550 this.Sfixed32Map[v25] *= -1
2551 }
2552 }
2553 }
2554 if r.Intn(5) != 0 {
2555 v26 := r.Intn(10)
2556 this.Fixed64Map = make(map[uint64]uint64)
2557 for i := 0; i < v26; i++ {
2558 v27 := uint64(uint64(r.Uint32()))
2559 this.Fixed64Map[v27] = uint64(uint64(r.Uint32()))
2560 }
2561 }
2562 if r.Intn(5) != 0 {
2563 v28 := r.Intn(10)
2564 this.Sfixed64Map = make(map[int64]int64)
2565 for i := 0; i < v28; i++ {
2566 v29 := int64(r.Int63())
2567 this.Sfixed64Map[v29] = int64(r.Int63())
2568 if r.Intn(2) == 0 {
2569 this.Sfixed64Map[v29] *= -1
2570 }
2571 }
2572 }
2573 if r.Intn(5) != 0 {
2574 v30 := r.Intn(10)
2575 this.BoolMap = make(map[bool]bool)
2576 for i := 0; i < v30; i++ {
2577 v31 := bool(bool(r.Intn(2) == 0))
2578 this.BoolMap[v31] = bool(bool(r.Intn(2) == 0))
2579 }
2580 }
2581 if r.Intn(5) != 0 {
2582 v32 := r.Intn(10)
2583 this.StringMap = make(map[string]string)
2584 for i := 0; i < v32; i++ {
2585 this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r)
2586 }
2587 }
2588 if r.Intn(5) != 0 {
2589 v33 := r.Intn(10)
2590 this.StringToBytesMap = make(map[string][]byte)
2591 for i := 0; i < v33; i++ {
2592 v34 := r.Intn(100)
2593 v35 := randStringMapsproto2(r)
2594 this.StringToBytesMap[v35] = make([]byte, v34)
2595 for i := 0; i < v34; i++ {
2596 this.StringToBytesMap[v35][i] = byte(r.Intn(256))
2597 }
2598 }
2599 }
2600 if r.Intn(5) != 0 {
2601 v36 := r.Intn(10)
2602 this.StringToEnumMap = make(map[string]MapEnum)
2603 for i := 0; i < v36; i++ {
2604 this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
2605 }
2606 }
2607 if r.Intn(5) != 0 {
2608 v37 := r.Intn(10)
2609 this.StringToMsgMap = make(map[string]*FloatingPoint)
2610 for i := 0; i < v37; i++ {
2611 this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy)
2612 }
2613 }
2614 if !easy && r.Intn(10) != 0 {
2615 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18)
2616 }
2617 return this
2618 }
2619
2620 func NewPopulatedAllMapsOrdered(r randyMapsproto2, easy bool) *AllMapsOrdered {
2621 this := &AllMapsOrdered{}
2622 if r.Intn(5) != 0 {
2623 v38 := r.Intn(10)
2624 this.StringToDoubleMap = make(map[string]float64)
2625 for i := 0; i < v38; i++ {
2626 v39 := randStringMapsproto2(r)
2627 this.StringToDoubleMap[v39] = float64(r.Float64())
2628 if r.Intn(2) == 0 {
2629 this.StringToDoubleMap[v39] *= -1
2630 }
2631 }
2632 }
2633 if r.Intn(5) != 0 {
2634 v40 := r.Intn(10)
2635 this.StringToFloatMap = make(map[string]float32)
2636 for i := 0; i < v40; i++ {
2637 v41 := randStringMapsproto2(r)
2638 this.StringToFloatMap[v41] = float32(r.Float32())
2639 if r.Intn(2) == 0 {
2640 this.StringToFloatMap[v41] *= -1
2641 }
2642 }
2643 }
2644 if r.Intn(5) != 0 {
2645 v42 := r.Intn(10)
2646 this.Int32Map = make(map[int32]int32)
2647 for i := 0; i < v42; i++ {
2648 v43 := int32(r.Int31())
2649 this.Int32Map[v43] = int32(r.Int31())
2650 if r.Intn(2) == 0 {
2651 this.Int32Map[v43] *= -1
2652 }
2653 }
2654 }
2655 if r.Intn(5) != 0 {
2656 v44 := r.Intn(10)
2657 this.Int64Map = make(map[int64]int64)
2658 for i := 0; i < v44; i++ {
2659 v45 := int64(r.Int63())
2660 this.Int64Map[v45] = int64(r.Int63())
2661 if r.Intn(2) == 0 {
2662 this.Int64Map[v45] *= -1
2663 }
2664 }
2665 }
2666 if r.Intn(5) != 0 {
2667 v46 := r.Intn(10)
2668 this.Uint32Map = make(map[uint32]uint32)
2669 for i := 0; i < v46; i++ {
2670 v47 := uint32(r.Uint32())
2671 this.Uint32Map[v47] = uint32(r.Uint32())
2672 }
2673 }
2674 if r.Intn(5) != 0 {
2675 v48 := r.Intn(10)
2676 this.Uint64Map = make(map[uint64]uint64)
2677 for i := 0; i < v48; i++ {
2678 v49 := uint64(uint64(r.Uint32()))
2679 this.Uint64Map[v49] = uint64(uint64(r.Uint32()))
2680 }
2681 }
2682 if r.Intn(5) != 0 {
2683 v50 := r.Intn(10)
2684 this.Sint32Map = make(map[int32]int32)
2685 for i := 0; i < v50; i++ {
2686 v51 := int32(r.Int31())
2687 this.Sint32Map[v51] = int32(r.Int31())
2688 if r.Intn(2) == 0 {
2689 this.Sint32Map[v51] *= -1
2690 }
2691 }
2692 }
2693 if r.Intn(5) != 0 {
2694 v52 := r.Intn(10)
2695 this.Sint64Map = make(map[int64]int64)
2696 for i := 0; i < v52; i++ {
2697 v53 := int64(r.Int63())
2698 this.Sint64Map[v53] = int64(r.Int63())
2699 if r.Intn(2) == 0 {
2700 this.Sint64Map[v53] *= -1
2701 }
2702 }
2703 }
2704 if r.Intn(5) != 0 {
2705 v54 := r.Intn(10)
2706 this.Fixed32Map = make(map[uint32]uint32)
2707 for i := 0; i < v54; i++ {
2708 v55 := uint32(r.Uint32())
2709 this.Fixed32Map[v55] = uint32(r.Uint32())
2710 }
2711 }
2712 if r.Intn(5) != 0 {
2713 v56 := r.Intn(10)
2714 this.Sfixed32Map = make(map[int32]int32)
2715 for i := 0; i < v56; i++ {
2716 v57 := int32(r.Int31())
2717 this.Sfixed32Map[v57] = int32(r.Int31())
2718 if r.Intn(2) == 0 {
2719 this.Sfixed32Map[v57] *= -1
2720 }
2721 }
2722 }
2723 if r.Intn(5) != 0 {
2724 v58 := r.Intn(10)
2725 this.Fixed64Map = make(map[uint64]uint64)
2726 for i := 0; i < v58; i++ {
2727 v59 := uint64(uint64(r.Uint32()))
2728 this.Fixed64Map[v59] = uint64(uint64(r.Uint32()))
2729 }
2730 }
2731 if r.Intn(5) != 0 {
2732 v60 := r.Intn(10)
2733 this.Sfixed64Map = make(map[int64]int64)
2734 for i := 0; i < v60; i++ {
2735 v61 := int64(r.Int63())
2736 this.Sfixed64Map[v61] = int64(r.Int63())
2737 if r.Intn(2) == 0 {
2738 this.Sfixed64Map[v61] *= -1
2739 }
2740 }
2741 }
2742 if r.Intn(5) != 0 {
2743 v62 := r.Intn(10)
2744 this.BoolMap = make(map[bool]bool)
2745 for i := 0; i < v62; i++ {
2746 v63 := bool(bool(r.Intn(2) == 0))
2747 this.BoolMap[v63] = bool(bool(r.Intn(2) == 0))
2748 }
2749 }
2750 if r.Intn(5) != 0 {
2751 v64 := r.Intn(10)
2752 this.StringMap = make(map[string]string)
2753 for i := 0; i < v64; i++ {
2754 this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r)
2755 }
2756 }
2757 if r.Intn(5) != 0 {
2758 v65 := r.Intn(10)
2759 this.StringToBytesMap = make(map[string][]byte)
2760 for i := 0; i < v65; i++ {
2761 v66 := r.Intn(100)
2762 v67 := randStringMapsproto2(r)
2763 this.StringToBytesMap[v67] = make([]byte, v66)
2764 for i := 0; i < v66; i++ {
2765 this.StringToBytesMap[v67][i] = byte(r.Intn(256))
2766 }
2767 }
2768 }
2769 if r.Intn(5) != 0 {
2770 v68 := r.Intn(10)
2771 this.StringToEnumMap = make(map[string]MapEnum)
2772 for i := 0; i < v68; i++ {
2773 this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
2774 }
2775 }
2776 if r.Intn(5) != 0 {
2777 v69 := r.Intn(10)
2778 this.StringToMsgMap = make(map[string]*FloatingPoint)
2779 for i := 0; i < v69; i++ {
2780 this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy)
2781 }
2782 }
2783 if !easy && r.Intn(10) != 0 {
2784 this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18)
2785 }
2786 return this
2787 }
2788
2789 type randyMapsproto2 interface {
2790 Float32() float32
2791 Float64() float64
2792 Int63() int64
2793 Int31() int32
2794 Uint32() uint32
2795 Intn(n int) int
2796 }
2797
2798 func randUTF8RuneMapsproto2(r randyMapsproto2) rune {
2799 ru := r.Intn(62)
2800 if ru < 10 {
2801 return rune(ru + 48)
2802 } else if ru < 36 {
2803 return rune(ru + 55)
2804 }
2805 return rune(ru + 61)
2806 }
2807 func randStringMapsproto2(r randyMapsproto2) string {
2808 v70 := r.Intn(100)
2809 tmps := make([]rune, v70)
2810 for i := 0; i < v70; i++ {
2811 tmps[i] = randUTF8RuneMapsproto2(r)
2812 }
2813 return string(tmps)
2814 }
2815 func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (dAtA []byte) {
2816 l := r.Intn(5)
2817 for i := 0; i < l; i++ {
2818 wire := r.Intn(4)
2819 if wire == 3 {
2820 wire = 5
2821 }
2822 fieldNumber := maxFieldNumber + r.Intn(100)
2823 dAtA = randFieldMapsproto2(dAtA, r, fieldNumber, wire)
2824 }
2825 return dAtA
2826 }
2827 func randFieldMapsproto2(dAtA []byte, r randyMapsproto2, fieldNumber int, wire int) []byte {
2828 key := uint32(fieldNumber)<<3 | uint32(wire)
2829 switch wire {
2830 case 0:
2831 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
2832 v71 := r.Int63()
2833 if r.Intn(2) == 0 {
2834 v71 *= -1
2835 }
2836 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(v71))
2837 case 1:
2838 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
2839 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
2840 case 2:
2841 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
2842 ll := r.Intn(100)
2843 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(ll))
2844 for j := 0; j < ll; j++ {
2845 dAtA = append(dAtA, byte(r.Intn(256)))
2846 }
2847 default:
2848 dAtA = encodeVarintPopulateMapsproto2(dAtA, uint64(key))
2849 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
2850 }
2851 return dAtA
2852 }
2853 func encodeVarintPopulateMapsproto2(dAtA []byte, v uint64) []byte {
2854 for v >= 1<<7 {
2855 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
2856 v >>= 7
2857 }
2858 dAtA = append(dAtA, uint8(v))
2859 return dAtA
2860 }
2861 func (m *FloatingPoint) Size() (n int) {
2862 if m == nil {
2863 return 0
2864 }
2865 var l int
2866 _ = l
2867 if m.F != nil {
2868 n += 9
2869 }
2870 if m.XXX_unrecognized != nil {
2871 n += len(m.XXX_unrecognized)
2872 }
2873 return n
2874 }
2875
2876 func (m *CustomMap) Size() (n int) {
2877 if m == nil {
2878 return 0
2879 }
2880 var l int
2881 _ = l
2882 if len(m.Nullable128S) > 0 {
2883 for k, v := range m.Nullable128S {
2884 _ = k
2885 _ = v
2886 l = 0
2887 if v != nil {
2888 l = v.Size()
2889 l += 1 + sovMapsproto2(uint64(l))
2890 }
2891 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
2892 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2893 }
2894 }
2895 if len(m.Uint128S) > 0 {
2896 for k, v := range m.Uint128S {
2897 _ = k
2898 _ = v
2899 l = 0
2900 l = v.Size()
2901 l += 1 + sovMapsproto2(uint64(l))
2902 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
2903 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2904 }
2905 }
2906 if len(m.NullableIds) > 0 {
2907 for k, v := range m.NullableIds {
2908 _ = k
2909 _ = v
2910 l = 0
2911 if v != nil {
2912 l = v.Size()
2913 l += 1 + sovMapsproto2(uint64(l))
2914 }
2915 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
2916 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2917 }
2918 }
2919 if len(m.Ids) > 0 {
2920 for k, v := range m.Ids {
2921 _ = k
2922 _ = v
2923 l = 0
2924 l = v.Size()
2925 l += 1 + sovMapsproto2(uint64(l))
2926 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
2927 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2928 }
2929 }
2930 if m.XXX_unrecognized != nil {
2931 n += len(m.XXX_unrecognized)
2932 }
2933 return n
2934 }
2935
2936 func (m *AllMaps) Size() (n int) {
2937 if m == nil {
2938 return 0
2939 }
2940 var l int
2941 _ = l
2942 if len(m.StringToDoubleMap) > 0 {
2943 for k, v := range m.StringToDoubleMap {
2944 _ = k
2945 _ = v
2946 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8
2947 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2948 }
2949 }
2950 if len(m.StringToFloatMap) > 0 {
2951 for k, v := range m.StringToFloatMap {
2952 _ = k
2953 _ = v
2954 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4
2955 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2956 }
2957 }
2958 if len(m.Int32Map) > 0 {
2959 for k, v := range m.Int32Map {
2960 _ = k
2961 _ = v
2962 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
2963 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2964 }
2965 }
2966 if len(m.Int64Map) > 0 {
2967 for k, v := range m.Int64Map {
2968 _ = k
2969 _ = v
2970 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
2971 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2972 }
2973 }
2974 if len(m.Uint32Map) > 0 {
2975 for k, v := range m.Uint32Map {
2976 _ = k
2977 _ = v
2978 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
2979 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2980 }
2981 }
2982 if len(m.Uint64Map) > 0 {
2983 for k, v := range m.Uint64Map {
2984 _ = k
2985 _ = v
2986 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
2987 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2988 }
2989 }
2990 if len(m.Sint32Map) > 0 {
2991 for k, v := range m.Sint32Map {
2992 _ = k
2993 _ = v
2994 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
2995 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
2996 }
2997 }
2998 if len(m.Sint64Map) > 0 {
2999 for k, v := range m.Sint64Map {
3000 _ = k
3001 _ = v
3002 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
3003 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3004 }
3005 }
3006 if len(m.Fixed32Map) > 0 {
3007 for k, v := range m.Fixed32Map {
3008 _ = k
3009 _ = v
3010 mapEntrySize := 1 + 4 + 1 + 4
3011 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3012 }
3013 }
3014 if len(m.Sfixed32Map) > 0 {
3015 for k, v := range m.Sfixed32Map {
3016 _ = k
3017 _ = v
3018 mapEntrySize := 1 + 4 + 1 + 4
3019 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3020 }
3021 }
3022 if len(m.Fixed64Map) > 0 {
3023 for k, v := range m.Fixed64Map {
3024 _ = k
3025 _ = v
3026 mapEntrySize := 1 + 8 + 1 + 8
3027 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3028 }
3029 }
3030 if len(m.Sfixed64Map) > 0 {
3031 for k, v := range m.Sfixed64Map {
3032 _ = k
3033 _ = v
3034 mapEntrySize := 1 + 8 + 1 + 8
3035 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3036 }
3037 }
3038 if len(m.BoolMap) > 0 {
3039 for k, v := range m.BoolMap {
3040 _ = k
3041 _ = v
3042 mapEntrySize := 1 + 1 + 1 + 1
3043 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3044 }
3045 }
3046 if len(m.StringMap) > 0 {
3047 for k, v := range m.StringMap {
3048 _ = k
3049 _ = v
3050 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v)))
3051 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3052 }
3053 }
3054 if len(m.StringToBytesMap) > 0 {
3055 for k, v := range m.StringToBytesMap {
3056 _ = k
3057 _ = v
3058 l = 0
3059 if v != nil {
3060 l = 1 + len(v) + sovMapsproto2(uint64(len(v)))
3061 }
3062 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3063 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3064 }
3065 }
3066 if len(m.StringToEnumMap) > 0 {
3067 for k, v := range m.StringToEnumMap {
3068 _ = k
3069 _ = v
3070 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v))
3071 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
3072 }
3073 }
3074 if len(m.StringToMsgMap) > 0 {
3075 for k, v := range m.StringToMsgMap {
3076 _ = k
3077 _ = v
3078 l = 0
3079 if v != nil {
3080 l = v.Size()
3081 l += 1 + sovMapsproto2(uint64(l))
3082 }
3083 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3084 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
3085 }
3086 }
3087 if m.XXX_unrecognized != nil {
3088 n += len(m.XXX_unrecognized)
3089 }
3090 return n
3091 }
3092
3093 func (m *AllMapsOrdered) Size() (n int) {
3094 if m == nil {
3095 return 0
3096 }
3097 var l int
3098 _ = l
3099 if len(m.StringToDoubleMap) > 0 {
3100 for k, v := range m.StringToDoubleMap {
3101 _ = k
3102 _ = v
3103 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8
3104 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3105 }
3106 }
3107 if len(m.StringToFloatMap) > 0 {
3108 for k, v := range m.StringToFloatMap {
3109 _ = k
3110 _ = v
3111 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4
3112 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3113 }
3114 }
3115 if len(m.Int32Map) > 0 {
3116 for k, v := range m.Int32Map {
3117 _ = k
3118 _ = v
3119 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3120 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3121 }
3122 }
3123 if len(m.Int64Map) > 0 {
3124 for k, v := range m.Int64Map {
3125 _ = k
3126 _ = v
3127 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3128 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3129 }
3130 }
3131 if len(m.Uint32Map) > 0 {
3132 for k, v := range m.Uint32Map {
3133 _ = k
3134 _ = v
3135 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3136 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3137 }
3138 }
3139 if len(m.Uint64Map) > 0 {
3140 for k, v := range m.Uint64Map {
3141 _ = k
3142 _ = v
3143 mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v))
3144 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3145 }
3146 }
3147 if len(m.Sint32Map) > 0 {
3148 for k, v := range m.Sint32Map {
3149 _ = k
3150 _ = v
3151 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
3152 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3153 }
3154 }
3155 if len(m.Sint64Map) > 0 {
3156 for k, v := range m.Sint64Map {
3157 _ = k
3158 _ = v
3159 mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v))
3160 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3161 }
3162 }
3163 if len(m.Fixed32Map) > 0 {
3164 for k, v := range m.Fixed32Map {
3165 _ = k
3166 _ = v
3167 mapEntrySize := 1 + 4 + 1 + 4
3168 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3169 }
3170 }
3171 if len(m.Sfixed32Map) > 0 {
3172 for k, v := range m.Sfixed32Map {
3173 _ = k
3174 _ = v
3175 mapEntrySize := 1 + 4 + 1 + 4
3176 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3177 }
3178 }
3179 if len(m.Fixed64Map) > 0 {
3180 for k, v := range m.Fixed64Map {
3181 _ = k
3182 _ = v
3183 mapEntrySize := 1 + 8 + 1 + 8
3184 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3185 }
3186 }
3187 if len(m.Sfixed64Map) > 0 {
3188 for k, v := range m.Sfixed64Map {
3189 _ = k
3190 _ = v
3191 mapEntrySize := 1 + 8 + 1 + 8
3192 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3193 }
3194 }
3195 if len(m.BoolMap) > 0 {
3196 for k, v := range m.BoolMap {
3197 _ = k
3198 _ = v
3199 mapEntrySize := 1 + 1 + 1 + 1
3200 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3201 }
3202 }
3203 if len(m.StringMap) > 0 {
3204 for k, v := range m.StringMap {
3205 _ = k
3206 _ = v
3207 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v)))
3208 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3209 }
3210 }
3211 if len(m.StringToBytesMap) > 0 {
3212 for k, v := range m.StringToBytesMap {
3213 _ = k
3214 _ = v
3215 l = 0
3216 if v != nil {
3217 l = 1 + len(v) + sovMapsproto2(uint64(len(v)))
3218 }
3219 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3220 n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize))
3221 }
3222 }
3223 if len(m.StringToEnumMap) > 0 {
3224 for k, v := range m.StringToEnumMap {
3225 _ = k
3226 _ = v
3227 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v))
3228 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
3229 }
3230 }
3231 if len(m.StringToMsgMap) > 0 {
3232 for k, v := range m.StringToMsgMap {
3233 _ = k
3234 _ = v
3235 l = 0
3236 if v != nil {
3237 l = v.Size()
3238 l += 1 + sovMapsproto2(uint64(l))
3239 }
3240 mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + l
3241 n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize))
3242 }
3243 }
3244 if m.XXX_unrecognized != nil {
3245 n += len(m.XXX_unrecognized)
3246 }
3247 return n
3248 }
3249
3250 func sovMapsproto2(x uint64) (n int) {
3251 return (math_bits.Len64(x|1) + 6) / 7
3252 }
3253 func sozMapsproto2(x uint64) (n int) {
3254 return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3255 }
3256 func (this *FloatingPoint) String() string {
3257 if this == nil {
3258 return "nil"
3259 }
3260 s := strings.Join([]string{`&FloatingPoint{`,
3261 `F:` + valueToStringMapsproto2(this.F) + `,`,
3262 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3263 `}`,
3264 }, "")
3265 return s
3266 }
3267 func (this *CustomMap) String() string {
3268 if this == nil {
3269 return "nil"
3270 }
3271 keysForNullable128S := make([]string, 0, len(this.Nullable128S))
3272 for k := range this.Nullable128S {
3273 keysForNullable128S = append(keysForNullable128S, k)
3274 }
3275 github_com_gogo_protobuf_sortkeys.Strings(keysForNullable128S)
3276 mapStringForNullable128S := "map[string]*github_com_gogo_protobuf_test_custom.Uint128{"
3277 for _, k := range keysForNullable128S {
3278 mapStringForNullable128S += fmt.Sprintf("%v: %v,", k, this.Nullable128S[k])
3279 }
3280 mapStringForNullable128S += "}"
3281 keysForUint128S := make([]string, 0, len(this.Uint128S))
3282 for k := range this.Uint128S {
3283 keysForUint128S = append(keysForUint128S, k)
3284 }
3285 github_com_gogo_protobuf_sortkeys.Strings(keysForUint128S)
3286 mapStringForUint128S := "map[string]github_com_gogo_protobuf_test_custom.Uint128{"
3287 for _, k := range keysForUint128S {
3288 mapStringForUint128S += fmt.Sprintf("%v: %v,", k, this.Uint128S[k])
3289 }
3290 mapStringForUint128S += "}"
3291 keysForNullableIds := make([]string, 0, len(this.NullableIds))
3292 for k := range this.NullableIds {
3293 keysForNullableIds = append(keysForNullableIds, k)
3294 }
3295 github_com_gogo_protobuf_sortkeys.Strings(keysForNullableIds)
3296 mapStringForNullableIds := "map[string]*github_com_gogo_protobuf_test.Uuid{"
3297 for _, k := range keysForNullableIds {
3298 mapStringForNullableIds += fmt.Sprintf("%v: %v,", k, this.NullableIds[k])
3299 }
3300 mapStringForNullableIds += "}"
3301 keysForIds := make([]string, 0, len(this.Ids))
3302 for k := range this.Ids {
3303 keysForIds = append(keysForIds, k)
3304 }
3305 github_com_gogo_protobuf_sortkeys.Strings(keysForIds)
3306 mapStringForIds := "map[string]github_com_gogo_protobuf_test.Uuid{"
3307 for _, k := range keysForIds {
3308 mapStringForIds += fmt.Sprintf("%v: %v,", k, this.Ids[k])
3309 }
3310 mapStringForIds += "}"
3311 s := strings.Join([]string{`&CustomMap{`,
3312 `Nullable128S:` + mapStringForNullable128S + `,`,
3313 `Uint128S:` + mapStringForUint128S + `,`,
3314 `NullableIds:` + mapStringForNullableIds + `,`,
3315 `Ids:` + mapStringForIds + `,`,
3316 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3317 `}`,
3318 }, "")
3319 return s
3320 }
3321 func (this *AllMaps) String() string {
3322 if this == nil {
3323 return "nil"
3324 }
3325 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
3326 for k := range this.StringToDoubleMap {
3327 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
3328 }
3329 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3330 mapStringForStringToDoubleMap := "map[string]float64{"
3331 for _, k := range keysForStringToDoubleMap {
3332 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
3333 }
3334 mapStringForStringToDoubleMap += "}"
3335 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
3336 for k := range this.StringToFloatMap {
3337 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
3338 }
3339 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3340 mapStringForStringToFloatMap := "map[string]float32{"
3341 for _, k := range keysForStringToFloatMap {
3342 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
3343 }
3344 mapStringForStringToFloatMap += "}"
3345 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
3346 for k := range this.Int32Map {
3347 keysForInt32Map = append(keysForInt32Map, k)
3348 }
3349 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3350 mapStringForInt32Map := "map[int32]int32{"
3351 for _, k := range keysForInt32Map {
3352 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
3353 }
3354 mapStringForInt32Map += "}"
3355 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
3356 for k := range this.Int64Map {
3357 keysForInt64Map = append(keysForInt64Map, k)
3358 }
3359 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3360 mapStringForInt64Map := "map[int64]int64{"
3361 for _, k := range keysForInt64Map {
3362 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
3363 }
3364 mapStringForInt64Map += "}"
3365 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
3366 for k := range this.Uint32Map {
3367 keysForUint32Map = append(keysForUint32Map, k)
3368 }
3369 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3370 mapStringForUint32Map := "map[uint32]uint32{"
3371 for _, k := range keysForUint32Map {
3372 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
3373 }
3374 mapStringForUint32Map += "}"
3375 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
3376 for k := range this.Uint64Map {
3377 keysForUint64Map = append(keysForUint64Map, k)
3378 }
3379 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3380 mapStringForUint64Map := "map[uint64]uint64{"
3381 for _, k := range keysForUint64Map {
3382 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
3383 }
3384 mapStringForUint64Map += "}"
3385 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
3386 for k := range this.Sint32Map {
3387 keysForSint32Map = append(keysForSint32Map, k)
3388 }
3389 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3390 mapStringForSint32Map := "map[int32]int32{"
3391 for _, k := range keysForSint32Map {
3392 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
3393 }
3394 mapStringForSint32Map += "}"
3395 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
3396 for k := range this.Sint64Map {
3397 keysForSint64Map = append(keysForSint64Map, k)
3398 }
3399 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3400 mapStringForSint64Map := "map[int64]int64{"
3401 for _, k := range keysForSint64Map {
3402 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
3403 }
3404 mapStringForSint64Map += "}"
3405 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
3406 for k := range this.Fixed32Map {
3407 keysForFixed32Map = append(keysForFixed32Map, k)
3408 }
3409 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3410 mapStringForFixed32Map := "map[uint32]uint32{"
3411 for _, k := range keysForFixed32Map {
3412 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
3413 }
3414 mapStringForFixed32Map += "}"
3415 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
3416 for k := range this.Sfixed32Map {
3417 keysForSfixed32Map = append(keysForSfixed32Map, k)
3418 }
3419 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3420 mapStringForSfixed32Map := "map[int32]int32{"
3421 for _, k := range keysForSfixed32Map {
3422 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
3423 }
3424 mapStringForSfixed32Map += "}"
3425 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
3426 for k := range this.Fixed64Map {
3427 keysForFixed64Map = append(keysForFixed64Map, k)
3428 }
3429 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3430 mapStringForFixed64Map := "map[uint64]uint64{"
3431 for _, k := range keysForFixed64Map {
3432 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
3433 }
3434 mapStringForFixed64Map += "}"
3435 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
3436 for k := range this.Sfixed64Map {
3437 keysForSfixed64Map = append(keysForSfixed64Map, k)
3438 }
3439 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3440 mapStringForSfixed64Map := "map[int64]int64{"
3441 for _, k := range keysForSfixed64Map {
3442 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
3443 }
3444 mapStringForSfixed64Map += "}"
3445 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
3446 for k := range this.BoolMap {
3447 keysForBoolMap = append(keysForBoolMap, k)
3448 }
3449 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3450 mapStringForBoolMap := "map[bool]bool{"
3451 for _, k := range keysForBoolMap {
3452 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
3453 }
3454 mapStringForBoolMap += "}"
3455 keysForStringMap := make([]string, 0, len(this.StringMap))
3456 for k := range this.StringMap {
3457 keysForStringMap = append(keysForStringMap, k)
3458 }
3459 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3460 mapStringForStringMap := "map[string]string{"
3461 for _, k := range keysForStringMap {
3462 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
3463 }
3464 mapStringForStringMap += "}"
3465 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
3466 for k := range this.StringToBytesMap {
3467 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
3468 }
3469 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3470 mapStringForStringToBytesMap := "map[string][]byte{"
3471 for _, k := range keysForStringToBytesMap {
3472 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
3473 }
3474 mapStringForStringToBytesMap += "}"
3475 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
3476 for k := range this.StringToEnumMap {
3477 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
3478 }
3479 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
3480 mapStringForStringToEnumMap := "map[string]MapEnum{"
3481 for _, k := range keysForStringToEnumMap {
3482 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
3483 }
3484 mapStringForStringToEnumMap += "}"
3485 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
3486 for k := range this.StringToMsgMap {
3487 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
3488 }
3489 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
3490 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
3491 for _, k := range keysForStringToMsgMap {
3492 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
3493 }
3494 mapStringForStringToMsgMap += "}"
3495 s := strings.Join([]string{`&AllMaps{`,
3496 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
3497 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
3498 `Int32Map:` + mapStringForInt32Map + `,`,
3499 `Int64Map:` + mapStringForInt64Map + `,`,
3500 `Uint32Map:` + mapStringForUint32Map + `,`,
3501 `Uint64Map:` + mapStringForUint64Map + `,`,
3502 `Sint32Map:` + mapStringForSint32Map + `,`,
3503 `Sint64Map:` + mapStringForSint64Map + `,`,
3504 `Fixed32Map:` + mapStringForFixed32Map + `,`,
3505 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
3506 `Fixed64Map:` + mapStringForFixed64Map + `,`,
3507 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
3508 `BoolMap:` + mapStringForBoolMap + `,`,
3509 `StringMap:` + mapStringForStringMap + `,`,
3510 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
3511 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
3512 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
3513 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3514 `}`,
3515 }, "")
3516 return s
3517 }
3518 func (this *AllMapsOrdered) String() string {
3519 if this == nil {
3520 return "nil"
3521 }
3522 keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
3523 for k := range this.StringToDoubleMap {
3524 keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
3525 }
3526 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
3527 mapStringForStringToDoubleMap := "map[string]float64{"
3528 for _, k := range keysForStringToDoubleMap {
3529 mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
3530 }
3531 mapStringForStringToDoubleMap += "}"
3532 keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
3533 for k := range this.StringToFloatMap {
3534 keysForStringToFloatMap = append(keysForStringToFloatMap, k)
3535 }
3536 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
3537 mapStringForStringToFloatMap := "map[string]float32{"
3538 for _, k := range keysForStringToFloatMap {
3539 mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
3540 }
3541 mapStringForStringToFloatMap += "}"
3542 keysForInt32Map := make([]int32, 0, len(this.Int32Map))
3543 for k := range this.Int32Map {
3544 keysForInt32Map = append(keysForInt32Map, k)
3545 }
3546 github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
3547 mapStringForInt32Map := "map[int32]int32{"
3548 for _, k := range keysForInt32Map {
3549 mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
3550 }
3551 mapStringForInt32Map += "}"
3552 keysForInt64Map := make([]int64, 0, len(this.Int64Map))
3553 for k := range this.Int64Map {
3554 keysForInt64Map = append(keysForInt64Map, k)
3555 }
3556 github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
3557 mapStringForInt64Map := "map[int64]int64{"
3558 for _, k := range keysForInt64Map {
3559 mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
3560 }
3561 mapStringForInt64Map += "}"
3562 keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
3563 for k := range this.Uint32Map {
3564 keysForUint32Map = append(keysForUint32Map, k)
3565 }
3566 github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
3567 mapStringForUint32Map := "map[uint32]uint32{"
3568 for _, k := range keysForUint32Map {
3569 mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
3570 }
3571 mapStringForUint32Map += "}"
3572 keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
3573 for k := range this.Uint64Map {
3574 keysForUint64Map = append(keysForUint64Map, k)
3575 }
3576 github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
3577 mapStringForUint64Map := "map[uint64]uint64{"
3578 for _, k := range keysForUint64Map {
3579 mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
3580 }
3581 mapStringForUint64Map += "}"
3582 keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
3583 for k := range this.Sint32Map {
3584 keysForSint32Map = append(keysForSint32Map, k)
3585 }
3586 github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
3587 mapStringForSint32Map := "map[int32]int32{"
3588 for _, k := range keysForSint32Map {
3589 mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
3590 }
3591 mapStringForSint32Map += "}"
3592 keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
3593 for k := range this.Sint64Map {
3594 keysForSint64Map = append(keysForSint64Map, k)
3595 }
3596 github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
3597 mapStringForSint64Map := "map[int64]int64{"
3598 for _, k := range keysForSint64Map {
3599 mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
3600 }
3601 mapStringForSint64Map += "}"
3602 keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
3603 for k := range this.Fixed32Map {
3604 keysForFixed32Map = append(keysForFixed32Map, k)
3605 }
3606 github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
3607 mapStringForFixed32Map := "map[uint32]uint32{"
3608 for _, k := range keysForFixed32Map {
3609 mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
3610 }
3611 mapStringForFixed32Map += "}"
3612 keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
3613 for k := range this.Sfixed32Map {
3614 keysForSfixed32Map = append(keysForSfixed32Map, k)
3615 }
3616 github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
3617 mapStringForSfixed32Map := "map[int32]int32{"
3618 for _, k := range keysForSfixed32Map {
3619 mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
3620 }
3621 mapStringForSfixed32Map += "}"
3622 keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
3623 for k := range this.Fixed64Map {
3624 keysForFixed64Map = append(keysForFixed64Map, k)
3625 }
3626 github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
3627 mapStringForFixed64Map := "map[uint64]uint64{"
3628 for _, k := range keysForFixed64Map {
3629 mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
3630 }
3631 mapStringForFixed64Map += "}"
3632 keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
3633 for k := range this.Sfixed64Map {
3634 keysForSfixed64Map = append(keysForSfixed64Map, k)
3635 }
3636 github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
3637 mapStringForSfixed64Map := "map[int64]int64{"
3638 for _, k := range keysForSfixed64Map {
3639 mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
3640 }
3641 mapStringForSfixed64Map += "}"
3642 keysForBoolMap := make([]bool, 0, len(this.BoolMap))
3643 for k := range this.BoolMap {
3644 keysForBoolMap = append(keysForBoolMap, k)
3645 }
3646 github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
3647 mapStringForBoolMap := "map[bool]bool{"
3648 for _, k := range keysForBoolMap {
3649 mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
3650 }
3651 mapStringForBoolMap += "}"
3652 keysForStringMap := make([]string, 0, len(this.StringMap))
3653 for k := range this.StringMap {
3654 keysForStringMap = append(keysForStringMap, k)
3655 }
3656 github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
3657 mapStringForStringMap := "map[string]string{"
3658 for _, k := range keysForStringMap {
3659 mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
3660 }
3661 mapStringForStringMap += "}"
3662 keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
3663 for k := range this.StringToBytesMap {
3664 keysForStringToBytesMap = append(keysForStringToBytesMap, k)
3665 }
3666 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
3667 mapStringForStringToBytesMap := "map[string][]byte{"
3668 for _, k := range keysForStringToBytesMap {
3669 mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
3670 }
3671 mapStringForStringToBytesMap += "}"
3672 keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
3673 for k := range this.StringToEnumMap {
3674 keysForStringToEnumMap = append(keysForStringToEnumMap, k)
3675 }
3676 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
3677 mapStringForStringToEnumMap := "map[string]MapEnum{"
3678 for _, k := range keysForStringToEnumMap {
3679 mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
3680 }
3681 mapStringForStringToEnumMap += "}"
3682 keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
3683 for k := range this.StringToMsgMap {
3684 keysForStringToMsgMap = append(keysForStringToMsgMap, k)
3685 }
3686 github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
3687 mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
3688 for _, k := range keysForStringToMsgMap {
3689 mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
3690 }
3691 mapStringForStringToMsgMap += "}"
3692 s := strings.Join([]string{`&AllMapsOrdered{`,
3693 `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
3694 `StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
3695 `Int32Map:` + mapStringForInt32Map + `,`,
3696 `Int64Map:` + mapStringForInt64Map + `,`,
3697 `Uint32Map:` + mapStringForUint32Map + `,`,
3698 `Uint64Map:` + mapStringForUint64Map + `,`,
3699 `Sint32Map:` + mapStringForSint32Map + `,`,
3700 `Sint64Map:` + mapStringForSint64Map + `,`,
3701 `Fixed32Map:` + mapStringForFixed32Map + `,`,
3702 `Sfixed32Map:` + mapStringForSfixed32Map + `,`,
3703 `Fixed64Map:` + mapStringForFixed64Map + `,`,
3704 `Sfixed64Map:` + mapStringForSfixed64Map + `,`,
3705 `BoolMap:` + mapStringForBoolMap + `,`,
3706 `StringMap:` + mapStringForStringMap + `,`,
3707 `StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
3708 `StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
3709 `StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
3710 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
3711 `}`,
3712 }, "")
3713 return s
3714 }
3715 func valueToStringMapsproto2(v interface{}) string {
3716 rv := reflect.ValueOf(v)
3717 if rv.IsNil() {
3718 return "nil"
3719 }
3720 pv := reflect.Indirect(rv).Interface()
3721 return fmt.Sprintf("*%v", pv)
3722 }
3723 func (m *FloatingPoint) Unmarshal(dAtA []byte) error {
3724 l := len(dAtA)
3725 iNdEx := 0
3726 for iNdEx < l {
3727 preIndex := iNdEx
3728 var wire uint64
3729 for shift := uint(0); ; shift += 7 {
3730 if shift >= 64 {
3731 return ErrIntOverflowMapsproto2
3732 }
3733 if iNdEx >= l {
3734 return io.ErrUnexpectedEOF
3735 }
3736 b := dAtA[iNdEx]
3737 iNdEx++
3738 wire |= uint64(b&0x7F) << shift
3739 if b < 0x80 {
3740 break
3741 }
3742 }
3743 fieldNum := int32(wire >> 3)
3744 wireType := int(wire & 0x7)
3745 if wireType == 4 {
3746 return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group")
3747 }
3748 if fieldNum <= 0 {
3749 return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire)
3750 }
3751 switch fieldNum {
3752 case 1:
3753 if wireType != 1 {
3754 return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
3755 }
3756 var v uint64
3757 if (iNdEx + 8) > l {
3758 return io.ErrUnexpectedEOF
3759 }
3760 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
3761 iNdEx += 8
3762 v2 := float64(math.Float64frombits(v))
3763 m.F = &v2
3764 default:
3765 iNdEx = preIndex
3766 skippy, err := skipMapsproto2(dAtA[iNdEx:])
3767 if err != nil {
3768 return err
3769 }
3770 if (skippy < 0) || (iNdEx+skippy) < 0 {
3771 return ErrInvalidLengthMapsproto2
3772 }
3773 if (iNdEx + skippy) > l {
3774 return io.ErrUnexpectedEOF
3775 }
3776 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
3777 iNdEx += skippy
3778 }
3779 }
3780
3781 if iNdEx > l {
3782 return io.ErrUnexpectedEOF
3783 }
3784 return nil
3785 }
3786 func (m *CustomMap) Unmarshal(dAtA []byte) error {
3787 l := len(dAtA)
3788 iNdEx := 0
3789 for iNdEx < l {
3790 preIndex := iNdEx
3791 var wire uint64
3792 for shift := uint(0); ; shift += 7 {
3793 if shift >= 64 {
3794 return ErrIntOverflowMapsproto2
3795 }
3796 if iNdEx >= l {
3797 return io.ErrUnexpectedEOF
3798 }
3799 b := dAtA[iNdEx]
3800 iNdEx++
3801 wire |= uint64(b&0x7F) << shift
3802 if b < 0x80 {
3803 break
3804 }
3805 }
3806 fieldNum := int32(wire >> 3)
3807 wireType := int(wire & 0x7)
3808 if wireType == 4 {
3809 return fmt.Errorf("proto: CustomMap: wiretype end group for non-group")
3810 }
3811 if fieldNum <= 0 {
3812 return fmt.Errorf("proto: CustomMap: illegal tag %d (wire type %d)", fieldNum, wire)
3813 }
3814 switch fieldNum {
3815 case 1:
3816 if wireType != 2 {
3817 return fmt.Errorf("proto: wrong wireType = %d for field Nullable128S", wireType)
3818 }
3819 var msglen int
3820 for shift := uint(0); ; shift += 7 {
3821 if shift >= 64 {
3822 return ErrIntOverflowMapsproto2
3823 }
3824 if iNdEx >= l {
3825 return io.ErrUnexpectedEOF
3826 }
3827 b := dAtA[iNdEx]
3828 iNdEx++
3829 msglen |= int(b&0x7F) << shift
3830 if b < 0x80 {
3831 break
3832 }
3833 }
3834 if msglen < 0 {
3835 return ErrInvalidLengthMapsproto2
3836 }
3837 postIndex := iNdEx + msglen
3838 if postIndex < 0 {
3839 return ErrInvalidLengthMapsproto2
3840 }
3841 if postIndex > l {
3842 return io.ErrUnexpectedEOF
3843 }
3844 if m.Nullable128S == nil {
3845 m.Nullable128S = make(map[string]*github_com_gogo_protobuf_test_custom.Uint128)
3846 }
3847 var mapkey string
3848 var mapvalue1 github_com_gogo_protobuf_test_custom.Uint128
3849 var mapvalue = &mapvalue1
3850 for iNdEx < postIndex {
3851 entryPreIndex := iNdEx
3852 var wire uint64
3853 for shift := uint(0); ; shift += 7 {
3854 if shift >= 64 {
3855 return ErrIntOverflowMapsproto2
3856 }
3857 if iNdEx >= l {
3858 return io.ErrUnexpectedEOF
3859 }
3860 b := dAtA[iNdEx]
3861 iNdEx++
3862 wire |= uint64(b&0x7F) << shift
3863 if b < 0x80 {
3864 break
3865 }
3866 }
3867 fieldNum := int32(wire >> 3)
3868 if fieldNum == 1 {
3869 var stringLenmapkey uint64
3870 for shift := uint(0); ; shift += 7 {
3871 if shift >= 64 {
3872 return ErrIntOverflowMapsproto2
3873 }
3874 if iNdEx >= l {
3875 return io.ErrUnexpectedEOF
3876 }
3877 b := dAtA[iNdEx]
3878 iNdEx++
3879 stringLenmapkey |= uint64(b&0x7F) << shift
3880 if b < 0x80 {
3881 break
3882 }
3883 }
3884 intStringLenmapkey := int(stringLenmapkey)
3885 if intStringLenmapkey < 0 {
3886 return ErrInvalidLengthMapsproto2
3887 }
3888 postStringIndexmapkey := iNdEx + intStringLenmapkey
3889 if postStringIndexmapkey < 0 {
3890 return ErrInvalidLengthMapsproto2
3891 }
3892 if postStringIndexmapkey > l {
3893 return io.ErrUnexpectedEOF
3894 }
3895 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
3896 iNdEx = postStringIndexmapkey
3897 } else if fieldNum == 2 {
3898 var mapbyteLen uint64
3899 for shift := uint(0); ; shift += 7 {
3900 if shift >= 64 {
3901 return ErrIntOverflowMapsproto2
3902 }
3903 if iNdEx >= l {
3904 return io.ErrUnexpectedEOF
3905 }
3906 b := dAtA[iNdEx]
3907 iNdEx++
3908 mapbyteLen |= uint64(b&0x7F) << shift
3909 if b < 0x80 {
3910 break
3911 }
3912 }
3913 intMapbyteLen := int(mapbyteLen)
3914 if intMapbyteLen < 0 {
3915 return ErrInvalidLengthMapsproto2
3916 }
3917 postbytesIndex := iNdEx + intMapbyteLen
3918 if postbytesIndex < 0 {
3919 return ErrInvalidLengthMapsproto2
3920 }
3921 if postbytesIndex > l {
3922 return io.ErrUnexpectedEOF
3923 }
3924 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
3925 return err
3926 }
3927 iNdEx = postbytesIndex
3928 } else {
3929 iNdEx = entryPreIndex
3930 skippy, err := skipMapsproto2(dAtA[iNdEx:])
3931 if err != nil {
3932 return err
3933 }
3934 if (skippy < 0) || (iNdEx+skippy) < 0 {
3935 return ErrInvalidLengthMapsproto2
3936 }
3937 if (iNdEx + skippy) > postIndex {
3938 return io.ErrUnexpectedEOF
3939 }
3940 iNdEx += skippy
3941 }
3942 }
3943 m.Nullable128S[mapkey] = ((*github_com_gogo_protobuf_test_custom.Uint128)(mapvalue))
3944 iNdEx = postIndex
3945 case 2:
3946 if wireType != 2 {
3947 return fmt.Errorf("proto: wrong wireType = %d for field Uint128S", wireType)
3948 }
3949 var msglen int
3950 for shift := uint(0); ; shift += 7 {
3951 if shift >= 64 {
3952 return ErrIntOverflowMapsproto2
3953 }
3954 if iNdEx >= l {
3955 return io.ErrUnexpectedEOF
3956 }
3957 b := dAtA[iNdEx]
3958 iNdEx++
3959 msglen |= int(b&0x7F) << shift
3960 if b < 0x80 {
3961 break
3962 }
3963 }
3964 if msglen < 0 {
3965 return ErrInvalidLengthMapsproto2
3966 }
3967 postIndex := iNdEx + msglen
3968 if postIndex < 0 {
3969 return ErrInvalidLengthMapsproto2
3970 }
3971 if postIndex > l {
3972 return io.ErrUnexpectedEOF
3973 }
3974 if m.Uint128S == nil {
3975 m.Uint128S = make(map[string]github_com_gogo_protobuf_test_custom.Uint128)
3976 }
3977 var mapkey string
3978 var mapvalue1 github_com_gogo_protobuf_test_custom.Uint128
3979 var mapvalue = &mapvalue1
3980 for iNdEx < postIndex {
3981 entryPreIndex := iNdEx
3982 var wire uint64
3983 for shift := uint(0); ; shift += 7 {
3984 if shift >= 64 {
3985 return ErrIntOverflowMapsproto2
3986 }
3987 if iNdEx >= l {
3988 return io.ErrUnexpectedEOF
3989 }
3990 b := dAtA[iNdEx]
3991 iNdEx++
3992 wire |= uint64(b&0x7F) << shift
3993 if b < 0x80 {
3994 break
3995 }
3996 }
3997 fieldNum := int32(wire >> 3)
3998 if fieldNum == 1 {
3999 var stringLenmapkey uint64
4000 for shift := uint(0); ; shift += 7 {
4001 if shift >= 64 {
4002 return ErrIntOverflowMapsproto2
4003 }
4004 if iNdEx >= l {
4005 return io.ErrUnexpectedEOF
4006 }
4007 b := dAtA[iNdEx]
4008 iNdEx++
4009 stringLenmapkey |= uint64(b&0x7F) << shift
4010 if b < 0x80 {
4011 break
4012 }
4013 }
4014 intStringLenmapkey := int(stringLenmapkey)
4015 if intStringLenmapkey < 0 {
4016 return ErrInvalidLengthMapsproto2
4017 }
4018 postStringIndexmapkey := iNdEx + intStringLenmapkey
4019 if postStringIndexmapkey < 0 {
4020 return ErrInvalidLengthMapsproto2
4021 }
4022 if postStringIndexmapkey > l {
4023 return io.ErrUnexpectedEOF
4024 }
4025 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4026 iNdEx = postStringIndexmapkey
4027 } else if fieldNum == 2 {
4028 var mapbyteLen uint64
4029 for shift := uint(0); ; shift += 7 {
4030 if shift >= 64 {
4031 return ErrIntOverflowMapsproto2
4032 }
4033 if iNdEx >= l {
4034 return io.ErrUnexpectedEOF
4035 }
4036 b := dAtA[iNdEx]
4037 iNdEx++
4038 mapbyteLen |= uint64(b&0x7F) << shift
4039 if b < 0x80 {
4040 break
4041 }
4042 }
4043 intMapbyteLen := int(mapbyteLen)
4044 if intMapbyteLen < 0 {
4045 return ErrInvalidLengthMapsproto2
4046 }
4047 postbytesIndex := iNdEx + intMapbyteLen
4048 if postbytesIndex < 0 {
4049 return ErrInvalidLengthMapsproto2
4050 }
4051 if postbytesIndex > l {
4052 return io.ErrUnexpectedEOF
4053 }
4054 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
4055 return err
4056 }
4057 iNdEx = postbytesIndex
4058 } else {
4059 iNdEx = entryPreIndex
4060 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4061 if err != nil {
4062 return err
4063 }
4064 if (skippy < 0) || (iNdEx+skippy) < 0 {
4065 return ErrInvalidLengthMapsproto2
4066 }
4067 if (iNdEx + skippy) > postIndex {
4068 return io.ErrUnexpectedEOF
4069 }
4070 iNdEx += skippy
4071 }
4072 }
4073 m.Uint128S[mapkey] = ((github_com_gogo_protobuf_test_custom.Uint128)(*mapvalue))
4074 iNdEx = postIndex
4075 case 3:
4076 if wireType != 2 {
4077 return fmt.Errorf("proto: wrong wireType = %d for field NullableIds", wireType)
4078 }
4079 var msglen int
4080 for shift := uint(0); ; shift += 7 {
4081 if shift >= 64 {
4082 return ErrIntOverflowMapsproto2
4083 }
4084 if iNdEx >= l {
4085 return io.ErrUnexpectedEOF
4086 }
4087 b := dAtA[iNdEx]
4088 iNdEx++
4089 msglen |= int(b&0x7F) << shift
4090 if b < 0x80 {
4091 break
4092 }
4093 }
4094 if msglen < 0 {
4095 return ErrInvalidLengthMapsproto2
4096 }
4097 postIndex := iNdEx + msglen
4098 if postIndex < 0 {
4099 return ErrInvalidLengthMapsproto2
4100 }
4101 if postIndex > l {
4102 return io.ErrUnexpectedEOF
4103 }
4104 if m.NullableIds == nil {
4105 m.NullableIds = make(map[string]*github_com_gogo_protobuf_test.Uuid)
4106 }
4107 var mapkey string
4108 var mapvalue1 github_com_gogo_protobuf_test.Uuid
4109 var mapvalue = &mapvalue1
4110 for iNdEx < postIndex {
4111 entryPreIndex := iNdEx
4112 var wire uint64
4113 for shift := uint(0); ; shift += 7 {
4114 if shift >= 64 {
4115 return ErrIntOverflowMapsproto2
4116 }
4117 if iNdEx >= l {
4118 return io.ErrUnexpectedEOF
4119 }
4120 b := dAtA[iNdEx]
4121 iNdEx++
4122 wire |= uint64(b&0x7F) << shift
4123 if b < 0x80 {
4124 break
4125 }
4126 }
4127 fieldNum := int32(wire >> 3)
4128 if fieldNum == 1 {
4129 var stringLenmapkey uint64
4130 for shift := uint(0); ; shift += 7 {
4131 if shift >= 64 {
4132 return ErrIntOverflowMapsproto2
4133 }
4134 if iNdEx >= l {
4135 return io.ErrUnexpectedEOF
4136 }
4137 b := dAtA[iNdEx]
4138 iNdEx++
4139 stringLenmapkey |= uint64(b&0x7F) << shift
4140 if b < 0x80 {
4141 break
4142 }
4143 }
4144 intStringLenmapkey := int(stringLenmapkey)
4145 if intStringLenmapkey < 0 {
4146 return ErrInvalidLengthMapsproto2
4147 }
4148 postStringIndexmapkey := iNdEx + intStringLenmapkey
4149 if postStringIndexmapkey < 0 {
4150 return ErrInvalidLengthMapsproto2
4151 }
4152 if postStringIndexmapkey > l {
4153 return io.ErrUnexpectedEOF
4154 }
4155 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4156 iNdEx = postStringIndexmapkey
4157 } else if fieldNum == 2 {
4158 var mapbyteLen uint64
4159 for shift := uint(0); ; shift += 7 {
4160 if shift >= 64 {
4161 return ErrIntOverflowMapsproto2
4162 }
4163 if iNdEx >= l {
4164 return io.ErrUnexpectedEOF
4165 }
4166 b := dAtA[iNdEx]
4167 iNdEx++
4168 mapbyteLen |= uint64(b&0x7F) << shift
4169 if b < 0x80 {
4170 break
4171 }
4172 }
4173 intMapbyteLen := int(mapbyteLen)
4174 if intMapbyteLen < 0 {
4175 return ErrInvalidLengthMapsproto2
4176 }
4177 postbytesIndex := iNdEx + intMapbyteLen
4178 if postbytesIndex < 0 {
4179 return ErrInvalidLengthMapsproto2
4180 }
4181 if postbytesIndex > l {
4182 return io.ErrUnexpectedEOF
4183 }
4184 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
4185 return err
4186 }
4187 iNdEx = postbytesIndex
4188 } else {
4189 iNdEx = entryPreIndex
4190 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4191 if err != nil {
4192 return err
4193 }
4194 if (skippy < 0) || (iNdEx+skippy) < 0 {
4195 return ErrInvalidLengthMapsproto2
4196 }
4197 if (iNdEx + skippy) > postIndex {
4198 return io.ErrUnexpectedEOF
4199 }
4200 iNdEx += skippy
4201 }
4202 }
4203 m.NullableIds[mapkey] = ((*github_com_gogo_protobuf_test.Uuid)(mapvalue))
4204 iNdEx = postIndex
4205 case 4:
4206 if wireType != 2 {
4207 return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
4208 }
4209 var msglen int
4210 for shift := uint(0); ; shift += 7 {
4211 if shift >= 64 {
4212 return ErrIntOverflowMapsproto2
4213 }
4214 if iNdEx >= l {
4215 return io.ErrUnexpectedEOF
4216 }
4217 b := dAtA[iNdEx]
4218 iNdEx++
4219 msglen |= int(b&0x7F) << shift
4220 if b < 0x80 {
4221 break
4222 }
4223 }
4224 if msglen < 0 {
4225 return ErrInvalidLengthMapsproto2
4226 }
4227 postIndex := iNdEx + msglen
4228 if postIndex < 0 {
4229 return ErrInvalidLengthMapsproto2
4230 }
4231 if postIndex > l {
4232 return io.ErrUnexpectedEOF
4233 }
4234 if m.Ids == nil {
4235 m.Ids = make(map[string]github_com_gogo_protobuf_test.Uuid)
4236 }
4237 var mapkey string
4238 var mapvalue1 github_com_gogo_protobuf_test.Uuid
4239 var mapvalue = &mapvalue1
4240 for iNdEx < postIndex {
4241 entryPreIndex := iNdEx
4242 var wire uint64
4243 for shift := uint(0); ; shift += 7 {
4244 if shift >= 64 {
4245 return ErrIntOverflowMapsproto2
4246 }
4247 if iNdEx >= l {
4248 return io.ErrUnexpectedEOF
4249 }
4250 b := dAtA[iNdEx]
4251 iNdEx++
4252 wire |= uint64(b&0x7F) << shift
4253 if b < 0x80 {
4254 break
4255 }
4256 }
4257 fieldNum := int32(wire >> 3)
4258 if fieldNum == 1 {
4259 var stringLenmapkey uint64
4260 for shift := uint(0); ; shift += 7 {
4261 if shift >= 64 {
4262 return ErrIntOverflowMapsproto2
4263 }
4264 if iNdEx >= l {
4265 return io.ErrUnexpectedEOF
4266 }
4267 b := dAtA[iNdEx]
4268 iNdEx++
4269 stringLenmapkey |= uint64(b&0x7F) << shift
4270 if b < 0x80 {
4271 break
4272 }
4273 }
4274 intStringLenmapkey := int(stringLenmapkey)
4275 if intStringLenmapkey < 0 {
4276 return ErrInvalidLengthMapsproto2
4277 }
4278 postStringIndexmapkey := iNdEx + intStringLenmapkey
4279 if postStringIndexmapkey < 0 {
4280 return ErrInvalidLengthMapsproto2
4281 }
4282 if postStringIndexmapkey > l {
4283 return io.ErrUnexpectedEOF
4284 }
4285 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4286 iNdEx = postStringIndexmapkey
4287 } else if fieldNum == 2 {
4288 var mapbyteLen uint64
4289 for shift := uint(0); ; shift += 7 {
4290 if shift >= 64 {
4291 return ErrIntOverflowMapsproto2
4292 }
4293 if iNdEx >= l {
4294 return io.ErrUnexpectedEOF
4295 }
4296 b := dAtA[iNdEx]
4297 iNdEx++
4298 mapbyteLen |= uint64(b&0x7F) << shift
4299 if b < 0x80 {
4300 break
4301 }
4302 }
4303 intMapbyteLen := int(mapbyteLen)
4304 if intMapbyteLen < 0 {
4305 return ErrInvalidLengthMapsproto2
4306 }
4307 postbytesIndex := iNdEx + intMapbyteLen
4308 if postbytesIndex < 0 {
4309 return ErrInvalidLengthMapsproto2
4310 }
4311 if postbytesIndex > l {
4312 return io.ErrUnexpectedEOF
4313 }
4314 if err := mapvalue.Unmarshal(dAtA[iNdEx:postbytesIndex]); err != nil {
4315 return err
4316 }
4317 iNdEx = postbytesIndex
4318 } else {
4319 iNdEx = entryPreIndex
4320 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4321 if err != nil {
4322 return err
4323 }
4324 if (skippy < 0) || (iNdEx+skippy) < 0 {
4325 return ErrInvalidLengthMapsproto2
4326 }
4327 if (iNdEx + skippy) > postIndex {
4328 return io.ErrUnexpectedEOF
4329 }
4330 iNdEx += skippy
4331 }
4332 }
4333 m.Ids[mapkey] = ((github_com_gogo_protobuf_test.Uuid)(*mapvalue))
4334 iNdEx = postIndex
4335 default:
4336 iNdEx = preIndex
4337 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4338 if err != nil {
4339 return err
4340 }
4341 if (skippy < 0) || (iNdEx+skippy) < 0 {
4342 return ErrInvalidLengthMapsproto2
4343 }
4344 if (iNdEx + skippy) > l {
4345 return io.ErrUnexpectedEOF
4346 }
4347 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
4348 iNdEx += skippy
4349 }
4350 }
4351
4352 if iNdEx > l {
4353 return io.ErrUnexpectedEOF
4354 }
4355 return nil
4356 }
4357 func (m *AllMaps) Unmarshal(dAtA []byte) error {
4358 l := len(dAtA)
4359 iNdEx := 0
4360 for iNdEx < l {
4361 preIndex := iNdEx
4362 var wire uint64
4363 for shift := uint(0); ; shift += 7 {
4364 if shift >= 64 {
4365 return ErrIntOverflowMapsproto2
4366 }
4367 if iNdEx >= l {
4368 return io.ErrUnexpectedEOF
4369 }
4370 b := dAtA[iNdEx]
4371 iNdEx++
4372 wire |= uint64(b&0x7F) << shift
4373 if b < 0x80 {
4374 break
4375 }
4376 }
4377 fieldNum := int32(wire >> 3)
4378 wireType := int(wire & 0x7)
4379 if wireType == 4 {
4380 return fmt.Errorf("proto: AllMaps: wiretype end group for non-group")
4381 }
4382 if fieldNum <= 0 {
4383 return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire)
4384 }
4385 switch fieldNum {
4386 case 1:
4387 if wireType != 2 {
4388 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
4389 }
4390 var msglen int
4391 for shift := uint(0); ; shift += 7 {
4392 if shift >= 64 {
4393 return ErrIntOverflowMapsproto2
4394 }
4395 if iNdEx >= l {
4396 return io.ErrUnexpectedEOF
4397 }
4398 b := dAtA[iNdEx]
4399 iNdEx++
4400 msglen |= int(b&0x7F) << shift
4401 if b < 0x80 {
4402 break
4403 }
4404 }
4405 if msglen < 0 {
4406 return ErrInvalidLengthMapsproto2
4407 }
4408 postIndex := iNdEx + msglen
4409 if postIndex < 0 {
4410 return ErrInvalidLengthMapsproto2
4411 }
4412 if postIndex > l {
4413 return io.ErrUnexpectedEOF
4414 }
4415 if m.StringToDoubleMap == nil {
4416 m.StringToDoubleMap = make(map[string]float64)
4417 }
4418 var mapkey string
4419 var mapvalue float64
4420 for iNdEx < postIndex {
4421 entryPreIndex := iNdEx
4422 var wire uint64
4423 for shift := uint(0); ; shift += 7 {
4424 if shift >= 64 {
4425 return ErrIntOverflowMapsproto2
4426 }
4427 if iNdEx >= l {
4428 return io.ErrUnexpectedEOF
4429 }
4430 b := dAtA[iNdEx]
4431 iNdEx++
4432 wire |= uint64(b&0x7F) << shift
4433 if b < 0x80 {
4434 break
4435 }
4436 }
4437 fieldNum := int32(wire >> 3)
4438 if fieldNum == 1 {
4439 var stringLenmapkey uint64
4440 for shift := uint(0); ; shift += 7 {
4441 if shift >= 64 {
4442 return ErrIntOverflowMapsproto2
4443 }
4444 if iNdEx >= l {
4445 return io.ErrUnexpectedEOF
4446 }
4447 b := dAtA[iNdEx]
4448 iNdEx++
4449 stringLenmapkey |= uint64(b&0x7F) << shift
4450 if b < 0x80 {
4451 break
4452 }
4453 }
4454 intStringLenmapkey := int(stringLenmapkey)
4455 if intStringLenmapkey < 0 {
4456 return ErrInvalidLengthMapsproto2
4457 }
4458 postStringIndexmapkey := iNdEx + intStringLenmapkey
4459 if postStringIndexmapkey < 0 {
4460 return ErrInvalidLengthMapsproto2
4461 }
4462 if postStringIndexmapkey > l {
4463 return io.ErrUnexpectedEOF
4464 }
4465 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4466 iNdEx = postStringIndexmapkey
4467 } else if fieldNum == 2 {
4468 var mapvaluetemp uint64
4469 if (iNdEx + 8) > l {
4470 return io.ErrUnexpectedEOF
4471 }
4472 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
4473 iNdEx += 8
4474 mapvalue = math.Float64frombits(mapvaluetemp)
4475 } else {
4476 iNdEx = entryPreIndex
4477 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4478 if err != nil {
4479 return err
4480 }
4481 if (skippy < 0) || (iNdEx+skippy) < 0 {
4482 return ErrInvalidLengthMapsproto2
4483 }
4484 if (iNdEx + skippy) > postIndex {
4485 return io.ErrUnexpectedEOF
4486 }
4487 iNdEx += skippy
4488 }
4489 }
4490 m.StringToDoubleMap[mapkey] = mapvalue
4491 iNdEx = postIndex
4492 case 2:
4493 if wireType != 2 {
4494 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
4495 }
4496 var msglen int
4497 for shift := uint(0); ; shift += 7 {
4498 if shift >= 64 {
4499 return ErrIntOverflowMapsproto2
4500 }
4501 if iNdEx >= l {
4502 return io.ErrUnexpectedEOF
4503 }
4504 b := dAtA[iNdEx]
4505 iNdEx++
4506 msglen |= int(b&0x7F) << shift
4507 if b < 0x80 {
4508 break
4509 }
4510 }
4511 if msglen < 0 {
4512 return ErrInvalidLengthMapsproto2
4513 }
4514 postIndex := iNdEx + msglen
4515 if postIndex < 0 {
4516 return ErrInvalidLengthMapsproto2
4517 }
4518 if postIndex > l {
4519 return io.ErrUnexpectedEOF
4520 }
4521 if m.StringToFloatMap == nil {
4522 m.StringToFloatMap = make(map[string]float32)
4523 }
4524 var mapkey string
4525 var mapvalue float32
4526 for iNdEx < postIndex {
4527 entryPreIndex := iNdEx
4528 var wire uint64
4529 for shift := uint(0); ; shift += 7 {
4530 if shift >= 64 {
4531 return ErrIntOverflowMapsproto2
4532 }
4533 if iNdEx >= l {
4534 return io.ErrUnexpectedEOF
4535 }
4536 b := dAtA[iNdEx]
4537 iNdEx++
4538 wire |= uint64(b&0x7F) << shift
4539 if b < 0x80 {
4540 break
4541 }
4542 }
4543 fieldNum := int32(wire >> 3)
4544 if fieldNum == 1 {
4545 var stringLenmapkey uint64
4546 for shift := uint(0); ; shift += 7 {
4547 if shift >= 64 {
4548 return ErrIntOverflowMapsproto2
4549 }
4550 if iNdEx >= l {
4551 return io.ErrUnexpectedEOF
4552 }
4553 b := dAtA[iNdEx]
4554 iNdEx++
4555 stringLenmapkey |= uint64(b&0x7F) << shift
4556 if b < 0x80 {
4557 break
4558 }
4559 }
4560 intStringLenmapkey := int(stringLenmapkey)
4561 if intStringLenmapkey < 0 {
4562 return ErrInvalidLengthMapsproto2
4563 }
4564 postStringIndexmapkey := iNdEx + intStringLenmapkey
4565 if postStringIndexmapkey < 0 {
4566 return ErrInvalidLengthMapsproto2
4567 }
4568 if postStringIndexmapkey > l {
4569 return io.ErrUnexpectedEOF
4570 }
4571 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
4572 iNdEx = postStringIndexmapkey
4573 } else if fieldNum == 2 {
4574 var mapvaluetemp uint32
4575 if (iNdEx + 4) > l {
4576 return io.ErrUnexpectedEOF
4577 }
4578 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
4579 iNdEx += 4
4580 mapvalue = math.Float32frombits(mapvaluetemp)
4581 } else {
4582 iNdEx = entryPreIndex
4583 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4584 if err != nil {
4585 return err
4586 }
4587 if (skippy < 0) || (iNdEx+skippy) < 0 {
4588 return ErrInvalidLengthMapsproto2
4589 }
4590 if (iNdEx + skippy) > postIndex {
4591 return io.ErrUnexpectedEOF
4592 }
4593 iNdEx += skippy
4594 }
4595 }
4596 m.StringToFloatMap[mapkey] = mapvalue
4597 iNdEx = postIndex
4598 case 3:
4599 if wireType != 2 {
4600 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
4601 }
4602 var msglen int
4603 for shift := uint(0); ; shift += 7 {
4604 if shift >= 64 {
4605 return ErrIntOverflowMapsproto2
4606 }
4607 if iNdEx >= l {
4608 return io.ErrUnexpectedEOF
4609 }
4610 b := dAtA[iNdEx]
4611 iNdEx++
4612 msglen |= int(b&0x7F) << shift
4613 if b < 0x80 {
4614 break
4615 }
4616 }
4617 if msglen < 0 {
4618 return ErrInvalidLengthMapsproto2
4619 }
4620 postIndex := iNdEx + msglen
4621 if postIndex < 0 {
4622 return ErrInvalidLengthMapsproto2
4623 }
4624 if postIndex > l {
4625 return io.ErrUnexpectedEOF
4626 }
4627 if m.Int32Map == nil {
4628 m.Int32Map = make(map[int32]int32)
4629 }
4630 var mapkey int32
4631 var mapvalue int32
4632 for iNdEx < postIndex {
4633 entryPreIndex := iNdEx
4634 var wire uint64
4635 for shift := uint(0); ; shift += 7 {
4636 if shift >= 64 {
4637 return ErrIntOverflowMapsproto2
4638 }
4639 if iNdEx >= l {
4640 return io.ErrUnexpectedEOF
4641 }
4642 b := dAtA[iNdEx]
4643 iNdEx++
4644 wire |= uint64(b&0x7F) << shift
4645 if b < 0x80 {
4646 break
4647 }
4648 }
4649 fieldNum := int32(wire >> 3)
4650 if fieldNum == 1 {
4651 for shift := uint(0); ; shift += 7 {
4652 if shift >= 64 {
4653 return ErrIntOverflowMapsproto2
4654 }
4655 if iNdEx >= l {
4656 return io.ErrUnexpectedEOF
4657 }
4658 b := dAtA[iNdEx]
4659 iNdEx++
4660 mapkey |= int32(b&0x7F) << shift
4661 if b < 0x80 {
4662 break
4663 }
4664 }
4665 } else if fieldNum == 2 {
4666 for shift := uint(0); ; shift += 7 {
4667 if shift >= 64 {
4668 return ErrIntOverflowMapsproto2
4669 }
4670 if iNdEx >= l {
4671 return io.ErrUnexpectedEOF
4672 }
4673 b := dAtA[iNdEx]
4674 iNdEx++
4675 mapvalue |= int32(b&0x7F) << shift
4676 if b < 0x80 {
4677 break
4678 }
4679 }
4680 } else {
4681 iNdEx = entryPreIndex
4682 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4683 if err != nil {
4684 return err
4685 }
4686 if (skippy < 0) || (iNdEx+skippy) < 0 {
4687 return ErrInvalidLengthMapsproto2
4688 }
4689 if (iNdEx + skippy) > postIndex {
4690 return io.ErrUnexpectedEOF
4691 }
4692 iNdEx += skippy
4693 }
4694 }
4695 m.Int32Map[mapkey] = mapvalue
4696 iNdEx = postIndex
4697 case 4:
4698 if wireType != 2 {
4699 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
4700 }
4701 var msglen int
4702 for shift := uint(0); ; shift += 7 {
4703 if shift >= 64 {
4704 return ErrIntOverflowMapsproto2
4705 }
4706 if iNdEx >= l {
4707 return io.ErrUnexpectedEOF
4708 }
4709 b := dAtA[iNdEx]
4710 iNdEx++
4711 msglen |= int(b&0x7F) << shift
4712 if b < 0x80 {
4713 break
4714 }
4715 }
4716 if msglen < 0 {
4717 return ErrInvalidLengthMapsproto2
4718 }
4719 postIndex := iNdEx + msglen
4720 if postIndex < 0 {
4721 return ErrInvalidLengthMapsproto2
4722 }
4723 if postIndex > l {
4724 return io.ErrUnexpectedEOF
4725 }
4726 if m.Int64Map == nil {
4727 m.Int64Map = make(map[int64]int64)
4728 }
4729 var mapkey int64
4730 var mapvalue int64
4731 for iNdEx < postIndex {
4732 entryPreIndex := iNdEx
4733 var wire uint64
4734 for shift := uint(0); ; shift += 7 {
4735 if shift >= 64 {
4736 return ErrIntOverflowMapsproto2
4737 }
4738 if iNdEx >= l {
4739 return io.ErrUnexpectedEOF
4740 }
4741 b := dAtA[iNdEx]
4742 iNdEx++
4743 wire |= uint64(b&0x7F) << shift
4744 if b < 0x80 {
4745 break
4746 }
4747 }
4748 fieldNum := int32(wire >> 3)
4749 if fieldNum == 1 {
4750 for shift := uint(0); ; shift += 7 {
4751 if shift >= 64 {
4752 return ErrIntOverflowMapsproto2
4753 }
4754 if iNdEx >= l {
4755 return io.ErrUnexpectedEOF
4756 }
4757 b := dAtA[iNdEx]
4758 iNdEx++
4759 mapkey |= int64(b&0x7F) << shift
4760 if b < 0x80 {
4761 break
4762 }
4763 }
4764 } else if fieldNum == 2 {
4765 for shift := uint(0); ; shift += 7 {
4766 if shift >= 64 {
4767 return ErrIntOverflowMapsproto2
4768 }
4769 if iNdEx >= l {
4770 return io.ErrUnexpectedEOF
4771 }
4772 b := dAtA[iNdEx]
4773 iNdEx++
4774 mapvalue |= int64(b&0x7F) << shift
4775 if b < 0x80 {
4776 break
4777 }
4778 }
4779 } else {
4780 iNdEx = entryPreIndex
4781 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4782 if err != nil {
4783 return err
4784 }
4785 if (skippy < 0) || (iNdEx+skippy) < 0 {
4786 return ErrInvalidLengthMapsproto2
4787 }
4788 if (iNdEx + skippy) > postIndex {
4789 return io.ErrUnexpectedEOF
4790 }
4791 iNdEx += skippy
4792 }
4793 }
4794 m.Int64Map[mapkey] = mapvalue
4795 iNdEx = postIndex
4796 case 5:
4797 if wireType != 2 {
4798 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
4799 }
4800 var msglen int
4801 for shift := uint(0); ; shift += 7 {
4802 if shift >= 64 {
4803 return ErrIntOverflowMapsproto2
4804 }
4805 if iNdEx >= l {
4806 return io.ErrUnexpectedEOF
4807 }
4808 b := dAtA[iNdEx]
4809 iNdEx++
4810 msglen |= int(b&0x7F) << shift
4811 if b < 0x80 {
4812 break
4813 }
4814 }
4815 if msglen < 0 {
4816 return ErrInvalidLengthMapsproto2
4817 }
4818 postIndex := iNdEx + msglen
4819 if postIndex < 0 {
4820 return ErrInvalidLengthMapsproto2
4821 }
4822 if postIndex > l {
4823 return io.ErrUnexpectedEOF
4824 }
4825 if m.Uint32Map == nil {
4826 m.Uint32Map = make(map[uint32]uint32)
4827 }
4828 var mapkey uint32
4829 var mapvalue uint32
4830 for iNdEx < postIndex {
4831 entryPreIndex := iNdEx
4832 var wire uint64
4833 for shift := uint(0); ; shift += 7 {
4834 if shift >= 64 {
4835 return ErrIntOverflowMapsproto2
4836 }
4837 if iNdEx >= l {
4838 return io.ErrUnexpectedEOF
4839 }
4840 b := dAtA[iNdEx]
4841 iNdEx++
4842 wire |= uint64(b&0x7F) << shift
4843 if b < 0x80 {
4844 break
4845 }
4846 }
4847 fieldNum := int32(wire >> 3)
4848 if fieldNum == 1 {
4849 for shift := uint(0); ; shift += 7 {
4850 if shift >= 64 {
4851 return ErrIntOverflowMapsproto2
4852 }
4853 if iNdEx >= l {
4854 return io.ErrUnexpectedEOF
4855 }
4856 b := dAtA[iNdEx]
4857 iNdEx++
4858 mapkey |= uint32(b&0x7F) << shift
4859 if b < 0x80 {
4860 break
4861 }
4862 }
4863 } else if fieldNum == 2 {
4864 for shift := uint(0); ; shift += 7 {
4865 if shift >= 64 {
4866 return ErrIntOverflowMapsproto2
4867 }
4868 if iNdEx >= l {
4869 return io.ErrUnexpectedEOF
4870 }
4871 b := dAtA[iNdEx]
4872 iNdEx++
4873 mapvalue |= uint32(b&0x7F) << shift
4874 if b < 0x80 {
4875 break
4876 }
4877 }
4878 } else {
4879 iNdEx = entryPreIndex
4880 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4881 if err != nil {
4882 return err
4883 }
4884 if (skippy < 0) || (iNdEx+skippy) < 0 {
4885 return ErrInvalidLengthMapsproto2
4886 }
4887 if (iNdEx + skippy) > postIndex {
4888 return io.ErrUnexpectedEOF
4889 }
4890 iNdEx += skippy
4891 }
4892 }
4893 m.Uint32Map[mapkey] = mapvalue
4894 iNdEx = postIndex
4895 case 6:
4896 if wireType != 2 {
4897 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
4898 }
4899 var msglen int
4900 for shift := uint(0); ; shift += 7 {
4901 if shift >= 64 {
4902 return ErrIntOverflowMapsproto2
4903 }
4904 if iNdEx >= l {
4905 return io.ErrUnexpectedEOF
4906 }
4907 b := dAtA[iNdEx]
4908 iNdEx++
4909 msglen |= int(b&0x7F) << shift
4910 if b < 0x80 {
4911 break
4912 }
4913 }
4914 if msglen < 0 {
4915 return ErrInvalidLengthMapsproto2
4916 }
4917 postIndex := iNdEx + msglen
4918 if postIndex < 0 {
4919 return ErrInvalidLengthMapsproto2
4920 }
4921 if postIndex > l {
4922 return io.ErrUnexpectedEOF
4923 }
4924 if m.Uint64Map == nil {
4925 m.Uint64Map = make(map[uint64]uint64)
4926 }
4927 var mapkey uint64
4928 var mapvalue uint64
4929 for iNdEx < postIndex {
4930 entryPreIndex := iNdEx
4931 var wire uint64
4932 for shift := uint(0); ; shift += 7 {
4933 if shift >= 64 {
4934 return ErrIntOverflowMapsproto2
4935 }
4936 if iNdEx >= l {
4937 return io.ErrUnexpectedEOF
4938 }
4939 b := dAtA[iNdEx]
4940 iNdEx++
4941 wire |= uint64(b&0x7F) << shift
4942 if b < 0x80 {
4943 break
4944 }
4945 }
4946 fieldNum := int32(wire >> 3)
4947 if fieldNum == 1 {
4948 for shift := uint(0); ; shift += 7 {
4949 if shift >= 64 {
4950 return ErrIntOverflowMapsproto2
4951 }
4952 if iNdEx >= l {
4953 return io.ErrUnexpectedEOF
4954 }
4955 b := dAtA[iNdEx]
4956 iNdEx++
4957 mapkey |= uint64(b&0x7F) << shift
4958 if b < 0x80 {
4959 break
4960 }
4961 }
4962 } else if fieldNum == 2 {
4963 for shift := uint(0); ; shift += 7 {
4964 if shift >= 64 {
4965 return ErrIntOverflowMapsproto2
4966 }
4967 if iNdEx >= l {
4968 return io.ErrUnexpectedEOF
4969 }
4970 b := dAtA[iNdEx]
4971 iNdEx++
4972 mapvalue |= uint64(b&0x7F) << shift
4973 if b < 0x80 {
4974 break
4975 }
4976 }
4977 } else {
4978 iNdEx = entryPreIndex
4979 skippy, err := skipMapsproto2(dAtA[iNdEx:])
4980 if err != nil {
4981 return err
4982 }
4983 if (skippy < 0) || (iNdEx+skippy) < 0 {
4984 return ErrInvalidLengthMapsproto2
4985 }
4986 if (iNdEx + skippy) > postIndex {
4987 return io.ErrUnexpectedEOF
4988 }
4989 iNdEx += skippy
4990 }
4991 }
4992 m.Uint64Map[mapkey] = mapvalue
4993 iNdEx = postIndex
4994 case 7:
4995 if wireType != 2 {
4996 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
4997 }
4998 var msglen int
4999 for shift := uint(0); ; shift += 7 {
5000 if shift >= 64 {
5001 return ErrIntOverflowMapsproto2
5002 }
5003 if iNdEx >= l {
5004 return io.ErrUnexpectedEOF
5005 }
5006 b := dAtA[iNdEx]
5007 iNdEx++
5008 msglen |= int(b&0x7F) << shift
5009 if b < 0x80 {
5010 break
5011 }
5012 }
5013 if msglen < 0 {
5014 return ErrInvalidLengthMapsproto2
5015 }
5016 postIndex := iNdEx + msglen
5017 if postIndex < 0 {
5018 return ErrInvalidLengthMapsproto2
5019 }
5020 if postIndex > l {
5021 return io.ErrUnexpectedEOF
5022 }
5023 if m.Sint32Map == nil {
5024 m.Sint32Map = make(map[int32]int32)
5025 }
5026 var mapkey int32
5027 var mapvalue int32
5028 for iNdEx < postIndex {
5029 entryPreIndex := iNdEx
5030 var wire uint64
5031 for shift := uint(0); ; shift += 7 {
5032 if shift >= 64 {
5033 return ErrIntOverflowMapsproto2
5034 }
5035 if iNdEx >= l {
5036 return io.ErrUnexpectedEOF
5037 }
5038 b := dAtA[iNdEx]
5039 iNdEx++
5040 wire |= uint64(b&0x7F) << shift
5041 if b < 0x80 {
5042 break
5043 }
5044 }
5045 fieldNum := int32(wire >> 3)
5046 if fieldNum == 1 {
5047 var mapkeytemp int32
5048 for shift := uint(0); ; shift += 7 {
5049 if shift >= 64 {
5050 return ErrIntOverflowMapsproto2
5051 }
5052 if iNdEx >= l {
5053 return io.ErrUnexpectedEOF
5054 }
5055 b := dAtA[iNdEx]
5056 iNdEx++
5057 mapkeytemp |= int32(b&0x7F) << shift
5058 if b < 0x80 {
5059 break
5060 }
5061 }
5062 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
5063 mapkey = int32(mapkeytemp)
5064 } else if fieldNum == 2 {
5065 var mapvaluetemp int32
5066 for shift := uint(0); ; shift += 7 {
5067 if shift >= 64 {
5068 return ErrIntOverflowMapsproto2
5069 }
5070 if iNdEx >= l {
5071 return io.ErrUnexpectedEOF
5072 }
5073 b := dAtA[iNdEx]
5074 iNdEx++
5075 mapvaluetemp |= int32(b&0x7F) << shift
5076 if b < 0x80 {
5077 break
5078 }
5079 }
5080 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
5081 mapvalue = int32(mapvaluetemp)
5082 } else {
5083 iNdEx = entryPreIndex
5084 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5085 if err != nil {
5086 return err
5087 }
5088 if (skippy < 0) || (iNdEx+skippy) < 0 {
5089 return ErrInvalidLengthMapsproto2
5090 }
5091 if (iNdEx + skippy) > postIndex {
5092 return io.ErrUnexpectedEOF
5093 }
5094 iNdEx += skippy
5095 }
5096 }
5097 m.Sint32Map[mapkey] = mapvalue
5098 iNdEx = postIndex
5099 case 8:
5100 if wireType != 2 {
5101 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
5102 }
5103 var msglen int
5104 for shift := uint(0); ; shift += 7 {
5105 if shift >= 64 {
5106 return ErrIntOverflowMapsproto2
5107 }
5108 if iNdEx >= l {
5109 return io.ErrUnexpectedEOF
5110 }
5111 b := dAtA[iNdEx]
5112 iNdEx++
5113 msglen |= int(b&0x7F) << shift
5114 if b < 0x80 {
5115 break
5116 }
5117 }
5118 if msglen < 0 {
5119 return ErrInvalidLengthMapsproto2
5120 }
5121 postIndex := iNdEx + msglen
5122 if postIndex < 0 {
5123 return ErrInvalidLengthMapsproto2
5124 }
5125 if postIndex > l {
5126 return io.ErrUnexpectedEOF
5127 }
5128 if m.Sint64Map == nil {
5129 m.Sint64Map = make(map[int64]int64)
5130 }
5131 var mapkey int64
5132 var mapvalue int64
5133 for iNdEx < postIndex {
5134 entryPreIndex := iNdEx
5135 var wire uint64
5136 for shift := uint(0); ; shift += 7 {
5137 if shift >= 64 {
5138 return ErrIntOverflowMapsproto2
5139 }
5140 if iNdEx >= l {
5141 return io.ErrUnexpectedEOF
5142 }
5143 b := dAtA[iNdEx]
5144 iNdEx++
5145 wire |= uint64(b&0x7F) << shift
5146 if b < 0x80 {
5147 break
5148 }
5149 }
5150 fieldNum := int32(wire >> 3)
5151 if fieldNum == 1 {
5152 var mapkeytemp uint64
5153 for shift := uint(0); ; shift += 7 {
5154 if shift >= 64 {
5155 return ErrIntOverflowMapsproto2
5156 }
5157 if iNdEx >= l {
5158 return io.ErrUnexpectedEOF
5159 }
5160 b := dAtA[iNdEx]
5161 iNdEx++
5162 mapkeytemp |= uint64(b&0x7F) << shift
5163 if b < 0x80 {
5164 break
5165 }
5166 }
5167 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
5168 mapkey = int64(mapkeytemp)
5169 } else if fieldNum == 2 {
5170 var mapvaluetemp uint64
5171 for shift := uint(0); ; shift += 7 {
5172 if shift >= 64 {
5173 return ErrIntOverflowMapsproto2
5174 }
5175 if iNdEx >= l {
5176 return io.ErrUnexpectedEOF
5177 }
5178 b := dAtA[iNdEx]
5179 iNdEx++
5180 mapvaluetemp |= uint64(b&0x7F) << shift
5181 if b < 0x80 {
5182 break
5183 }
5184 }
5185 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
5186 mapvalue = int64(mapvaluetemp)
5187 } else {
5188 iNdEx = entryPreIndex
5189 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5190 if err != nil {
5191 return err
5192 }
5193 if (skippy < 0) || (iNdEx+skippy) < 0 {
5194 return ErrInvalidLengthMapsproto2
5195 }
5196 if (iNdEx + skippy) > postIndex {
5197 return io.ErrUnexpectedEOF
5198 }
5199 iNdEx += skippy
5200 }
5201 }
5202 m.Sint64Map[mapkey] = mapvalue
5203 iNdEx = postIndex
5204 case 9:
5205 if wireType != 2 {
5206 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
5207 }
5208 var msglen int
5209 for shift := uint(0); ; shift += 7 {
5210 if shift >= 64 {
5211 return ErrIntOverflowMapsproto2
5212 }
5213 if iNdEx >= l {
5214 return io.ErrUnexpectedEOF
5215 }
5216 b := dAtA[iNdEx]
5217 iNdEx++
5218 msglen |= int(b&0x7F) << shift
5219 if b < 0x80 {
5220 break
5221 }
5222 }
5223 if msglen < 0 {
5224 return ErrInvalidLengthMapsproto2
5225 }
5226 postIndex := iNdEx + msglen
5227 if postIndex < 0 {
5228 return ErrInvalidLengthMapsproto2
5229 }
5230 if postIndex > l {
5231 return io.ErrUnexpectedEOF
5232 }
5233 if m.Fixed32Map == nil {
5234 m.Fixed32Map = make(map[uint32]uint32)
5235 }
5236 var mapkey uint32
5237 var mapvalue uint32
5238 for iNdEx < postIndex {
5239 entryPreIndex := iNdEx
5240 var wire uint64
5241 for shift := uint(0); ; shift += 7 {
5242 if shift >= 64 {
5243 return ErrIntOverflowMapsproto2
5244 }
5245 if iNdEx >= l {
5246 return io.ErrUnexpectedEOF
5247 }
5248 b := dAtA[iNdEx]
5249 iNdEx++
5250 wire |= uint64(b&0x7F) << shift
5251 if b < 0x80 {
5252 break
5253 }
5254 }
5255 fieldNum := int32(wire >> 3)
5256 if fieldNum == 1 {
5257 if (iNdEx + 4) > l {
5258 return io.ErrUnexpectedEOF
5259 }
5260 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
5261 iNdEx += 4
5262 } else if fieldNum == 2 {
5263 if (iNdEx + 4) > l {
5264 return io.ErrUnexpectedEOF
5265 }
5266 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
5267 iNdEx += 4
5268 } else {
5269 iNdEx = entryPreIndex
5270 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5271 if err != nil {
5272 return err
5273 }
5274 if (skippy < 0) || (iNdEx+skippy) < 0 {
5275 return ErrInvalidLengthMapsproto2
5276 }
5277 if (iNdEx + skippy) > postIndex {
5278 return io.ErrUnexpectedEOF
5279 }
5280 iNdEx += skippy
5281 }
5282 }
5283 m.Fixed32Map[mapkey] = mapvalue
5284 iNdEx = postIndex
5285 case 10:
5286 if wireType != 2 {
5287 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
5288 }
5289 var msglen int
5290 for shift := uint(0); ; shift += 7 {
5291 if shift >= 64 {
5292 return ErrIntOverflowMapsproto2
5293 }
5294 if iNdEx >= l {
5295 return io.ErrUnexpectedEOF
5296 }
5297 b := dAtA[iNdEx]
5298 iNdEx++
5299 msglen |= int(b&0x7F) << shift
5300 if b < 0x80 {
5301 break
5302 }
5303 }
5304 if msglen < 0 {
5305 return ErrInvalidLengthMapsproto2
5306 }
5307 postIndex := iNdEx + msglen
5308 if postIndex < 0 {
5309 return ErrInvalidLengthMapsproto2
5310 }
5311 if postIndex > l {
5312 return io.ErrUnexpectedEOF
5313 }
5314 if m.Sfixed32Map == nil {
5315 m.Sfixed32Map = make(map[int32]int32)
5316 }
5317 var mapkey int32
5318 var mapvalue int32
5319 for iNdEx < postIndex {
5320 entryPreIndex := iNdEx
5321 var wire uint64
5322 for shift := uint(0); ; shift += 7 {
5323 if shift >= 64 {
5324 return ErrIntOverflowMapsproto2
5325 }
5326 if iNdEx >= l {
5327 return io.ErrUnexpectedEOF
5328 }
5329 b := dAtA[iNdEx]
5330 iNdEx++
5331 wire |= uint64(b&0x7F) << shift
5332 if b < 0x80 {
5333 break
5334 }
5335 }
5336 fieldNum := int32(wire >> 3)
5337 if fieldNum == 1 {
5338 if (iNdEx + 4) > l {
5339 return io.ErrUnexpectedEOF
5340 }
5341 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
5342 iNdEx += 4
5343 } else if fieldNum == 2 {
5344 if (iNdEx + 4) > l {
5345 return io.ErrUnexpectedEOF
5346 }
5347 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
5348 iNdEx += 4
5349 } else {
5350 iNdEx = entryPreIndex
5351 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5352 if err != nil {
5353 return err
5354 }
5355 if (skippy < 0) || (iNdEx+skippy) < 0 {
5356 return ErrInvalidLengthMapsproto2
5357 }
5358 if (iNdEx + skippy) > postIndex {
5359 return io.ErrUnexpectedEOF
5360 }
5361 iNdEx += skippy
5362 }
5363 }
5364 m.Sfixed32Map[mapkey] = mapvalue
5365 iNdEx = postIndex
5366 case 11:
5367 if wireType != 2 {
5368 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
5369 }
5370 var msglen int
5371 for shift := uint(0); ; shift += 7 {
5372 if shift >= 64 {
5373 return ErrIntOverflowMapsproto2
5374 }
5375 if iNdEx >= l {
5376 return io.ErrUnexpectedEOF
5377 }
5378 b := dAtA[iNdEx]
5379 iNdEx++
5380 msglen |= int(b&0x7F) << shift
5381 if b < 0x80 {
5382 break
5383 }
5384 }
5385 if msglen < 0 {
5386 return ErrInvalidLengthMapsproto2
5387 }
5388 postIndex := iNdEx + msglen
5389 if postIndex < 0 {
5390 return ErrInvalidLengthMapsproto2
5391 }
5392 if postIndex > l {
5393 return io.ErrUnexpectedEOF
5394 }
5395 if m.Fixed64Map == nil {
5396 m.Fixed64Map = make(map[uint64]uint64)
5397 }
5398 var mapkey uint64
5399 var mapvalue uint64
5400 for iNdEx < postIndex {
5401 entryPreIndex := iNdEx
5402 var wire uint64
5403 for shift := uint(0); ; shift += 7 {
5404 if shift >= 64 {
5405 return ErrIntOverflowMapsproto2
5406 }
5407 if iNdEx >= l {
5408 return io.ErrUnexpectedEOF
5409 }
5410 b := dAtA[iNdEx]
5411 iNdEx++
5412 wire |= uint64(b&0x7F) << shift
5413 if b < 0x80 {
5414 break
5415 }
5416 }
5417 fieldNum := int32(wire >> 3)
5418 if fieldNum == 1 {
5419 if (iNdEx + 8) > l {
5420 return io.ErrUnexpectedEOF
5421 }
5422 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5423 iNdEx += 8
5424 } else if fieldNum == 2 {
5425 if (iNdEx + 8) > l {
5426 return io.ErrUnexpectedEOF
5427 }
5428 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5429 iNdEx += 8
5430 } else {
5431 iNdEx = entryPreIndex
5432 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5433 if err != nil {
5434 return err
5435 }
5436 if (skippy < 0) || (iNdEx+skippy) < 0 {
5437 return ErrInvalidLengthMapsproto2
5438 }
5439 if (iNdEx + skippy) > postIndex {
5440 return io.ErrUnexpectedEOF
5441 }
5442 iNdEx += skippy
5443 }
5444 }
5445 m.Fixed64Map[mapkey] = mapvalue
5446 iNdEx = postIndex
5447 case 12:
5448 if wireType != 2 {
5449 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
5450 }
5451 var msglen int
5452 for shift := uint(0); ; shift += 7 {
5453 if shift >= 64 {
5454 return ErrIntOverflowMapsproto2
5455 }
5456 if iNdEx >= l {
5457 return io.ErrUnexpectedEOF
5458 }
5459 b := dAtA[iNdEx]
5460 iNdEx++
5461 msglen |= int(b&0x7F) << shift
5462 if b < 0x80 {
5463 break
5464 }
5465 }
5466 if msglen < 0 {
5467 return ErrInvalidLengthMapsproto2
5468 }
5469 postIndex := iNdEx + msglen
5470 if postIndex < 0 {
5471 return ErrInvalidLengthMapsproto2
5472 }
5473 if postIndex > l {
5474 return io.ErrUnexpectedEOF
5475 }
5476 if m.Sfixed64Map == nil {
5477 m.Sfixed64Map = make(map[int64]int64)
5478 }
5479 var mapkey int64
5480 var mapvalue int64
5481 for iNdEx < postIndex {
5482 entryPreIndex := iNdEx
5483 var wire uint64
5484 for shift := uint(0); ; shift += 7 {
5485 if shift >= 64 {
5486 return ErrIntOverflowMapsproto2
5487 }
5488 if iNdEx >= l {
5489 return io.ErrUnexpectedEOF
5490 }
5491 b := dAtA[iNdEx]
5492 iNdEx++
5493 wire |= uint64(b&0x7F) << shift
5494 if b < 0x80 {
5495 break
5496 }
5497 }
5498 fieldNum := int32(wire >> 3)
5499 if fieldNum == 1 {
5500 if (iNdEx + 8) > l {
5501 return io.ErrUnexpectedEOF
5502 }
5503 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5504 iNdEx += 8
5505 } else if fieldNum == 2 {
5506 if (iNdEx + 8) > l {
5507 return io.ErrUnexpectedEOF
5508 }
5509 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
5510 iNdEx += 8
5511 } else {
5512 iNdEx = entryPreIndex
5513 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5514 if err != nil {
5515 return err
5516 }
5517 if (skippy < 0) || (iNdEx+skippy) < 0 {
5518 return ErrInvalidLengthMapsproto2
5519 }
5520 if (iNdEx + skippy) > postIndex {
5521 return io.ErrUnexpectedEOF
5522 }
5523 iNdEx += skippy
5524 }
5525 }
5526 m.Sfixed64Map[mapkey] = mapvalue
5527 iNdEx = postIndex
5528 case 13:
5529 if wireType != 2 {
5530 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
5531 }
5532 var msglen int
5533 for shift := uint(0); ; shift += 7 {
5534 if shift >= 64 {
5535 return ErrIntOverflowMapsproto2
5536 }
5537 if iNdEx >= l {
5538 return io.ErrUnexpectedEOF
5539 }
5540 b := dAtA[iNdEx]
5541 iNdEx++
5542 msglen |= int(b&0x7F) << shift
5543 if b < 0x80 {
5544 break
5545 }
5546 }
5547 if msglen < 0 {
5548 return ErrInvalidLengthMapsproto2
5549 }
5550 postIndex := iNdEx + msglen
5551 if postIndex < 0 {
5552 return ErrInvalidLengthMapsproto2
5553 }
5554 if postIndex > l {
5555 return io.ErrUnexpectedEOF
5556 }
5557 if m.BoolMap == nil {
5558 m.BoolMap = make(map[bool]bool)
5559 }
5560 var mapkey bool
5561 var mapvalue bool
5562 for iNdEx < postIndex {
5563 entryPreIndex := iNdEx
5564 var wire uint64
5565 for shift := uint(0); ; shift += 7 {
5566 if shift >= 64 {
5567 return ErrIntOverflowMapsproto2
5568 }
5569 if iNdEx >= l {
5570 return io.ErrUnexpectedEOF
5571 }
5572 b := dAtA[iNdEx]
5573 iNdEx++
5574 wire |= uint64(b&0x7F) << shift
5575 if b < 0x80 {
5576 break
5577 }
5578 }
5579 fieldNum := int32(wire >> 3)
5580 if fieldNum == 1 {
5581 var mapkeytemp int
5582 for shift := uint(0); ; shift += 7 {
5583 if shift >= 64 {
5584 return ErrIntOverflowMapsproto2
5585 }
5586 if iNdEx >= l {
5587 return io.ErrUnexpectedEOF
5588 }
5589 b := dAtA[iNdEx]
5590 iNdEx++
5591 mapkeytemp |= int(b&0x7F) << shift
5592 if b < 0x80 {
5593 break
5594 }
5595 }
5596 mapkey = bool(mapkeytemp != 0)
5597 } else if fieldNum == 2 {
5598 var mapvaluetemp int
5599 for shift := uint(0); ; shift += 7 {
5600 if shift >= 64 {
5601 return ErrIntOverflowMapsproto2
5602 }
5603 if iNdEx >= l {
5604 return io.ErrUnexpectedEOF
5605 }
5606 b := dAtA[iNdEx]
5607 iNdEx++
5608 mapvaluetemp |= int(b&0x7F) << shift
5609 if b < 0x80 {
5610 break
5611 }
5612 }
5613 mapvalue = bool(mapvaluetemp != 0)
5614 } else {
5615 iNdEx = entryPreIndex
5616 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5617 if err != nil {
5618 return err
5619 }
5620 if (skippy < 0) || (iNdEx+skippy) < 0 {
5621 return ErrInvalidLengthMapsproto2
5622 }
5623 if (iNdEx + skippy) > postIndex {
5624 return io.ErrUnexpectedEOF
5625 }
5626 iNdEx += skippy
5627 }
5628 }
5629 m.BoolMap[mapkey] = mapvalue
5630 iNdEx = postIndex
5631 case 14:
5632 if wireType != 2 {
5633 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
5634 }
5635 var msglen int
5636 for shift := uint(0); ; shift += 7 {
5637 if shift >= 64 {
5638 return ErrIntOverflowMapsproto2
5639 }
5640 if iNdEx >= l {
5641 return io.ErrUnexpectedEOF
5642 }
5643 b := dAtA[iNdEx]
5644 iNdEx++
5645 msglen |= int(b&0x7F) << shift
5646 if b < 0x80 {
5647 break
5648 }
5649 }
5650 if msglen < 0 {
5651 return ErrInvalidLengthMapsproto2
5652 }
5653 postIndex := iNdEx + msglen
5654 if postIndex < 0 {
5655 return ErrInvalidLengthMapsproto2
5656 }
5657 if postIndex > l {
5658 return io.ErrUnexpectedEOF
5659 }
5660 if m.StringMap == nil {
5661 m.StringMap = make(map[string]string)
5662 }
5663 var mapkey string
5664 var mapvalue string
5665 for iNdEx < postIndex {
5666 entryPreIndex := iNdEx
5667 var wire uint64
5668 for shift := uint(0); ; shift += 7 {
5669 if shift >= 64 {
5670 return ErrIntOverflowMapsproto2
5671 }
5672 if iNdEx >= l {
5673 return io.ErrUnexpectedEOF
5674 }
5675 b := dAtA[iNdEx]
5676 iNdEx++
5677 wire |= uint64(b&0x7F) << shift
5678 if b < 0x80 {
5679 break
5680 }
5681 }
5682 fieldNum := int32(wire >> 3)
5683 if fieldNum == 1 {
5684 var stringLenmapkey uint64
5685 for shift := uint(0); ; shift += 7 {
5686 if shift >= 64 {
5687 return ErrIntOverflowMapsproto2
5688 }
5689 if iNdEx >= l {
5690 return io.ErrUnexpectedEOF
5691 }
5692 b := dAtA[iNdEx]
5693 iNdEx++
5694 stringLenmapkey |= uint64(b&0x7F) << shift
5695 if b < 0x80 {
5696 break
5697 }
5698 }
5699 intStringLenmapkey := int(stringLenmapkey)
5700 if intStringLenmapkey < 0 {
5701 return ErrInvalidLengthMapsproto2
5702 }
5703 postStringIndexmapkey := iNdEx + intStringLenmapkey
5704 if postStringIndexmapkey < 0 {
5705 return ErrInvalidLengthMapsproto2
5706 }
5707 if postStringIndexmapkey > l {
5708 return io.ErrUnexpectedEOF
5709 }
5710 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5711 iNdEx = postStringIndexmapkey
5712 } else if fieldNum == 2 {
5713 var stringLenmapvalue uint64
5714 for shift := uint(0); ; shift += 7 {
5715 if shift >= 64 {
5716 return ErrIntOverflowMapsproto2
5717 }
5718 if iNdEx >= l {
5719 return io.ErrUnexpectedEOF
5720 }
5721 b := dAtA[iNdEx]
5722 iNdEx++
5723 stringLenmapvalue |= uint64(b&0x7F) << shift
5724 if b < 0x80 {
5725 break
5726 }
5727 }
5728 intStringLenmapvalue := int(stringLenmapvalue)
5729 if intStringLenmapvalue < 0 {
5730 return ErrInvalidLengthMapsproto2
5731 }
5732 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
5733 if postStringIndexmapvalue < 0 {
5734 return ErrInvalidLengthMapsproto2
5735 }
5736 if postStringIndexmapvalue > l {
5737 return io.ErrUnexpectedEOF
5738 }
5739 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
5740 iNdEx = postStringIndexmapvalue
5741 } else {
5742 iNdEx = entryPreIndex
5743 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5744 if err != nil {
5745 return err
5746 }
5747 if (skippy < 0) || (iNdEx+skippy) < 0 {
5748 return ErrInvalidLengthMapsproto2
5749 }
5750 if (iNdEx + skippy) > postIndex {
5751 return io.ErrUnexpectedEOF
5752 }
5753 iNdEx += skippy
5754 }
5755 }
5756 m.StringMap[mapkey] = mapvalue
5757 iNdEx = postIndex
5758 case 15:
5759 if wireType != 2 {
5760 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
5761 }
5762 var msglen int
5763 for shift := uint(0); ; shift += 7 {
5764 if shift >= 64 {
5765 return ErrIntOverflowMapsproto2
5766 }
5767 if iNdEx >= l {
5768 return io.ErrUnexpectedEOF
5769 }
5770 b := dAtA[iNdEx]
5771 iNdEx++
5772 msglen |= int(b&0x7F) << shift
5773 if b < 0x80 {
5774 break
5775 }
5776 }
5777 if msglen < 0 {
5778 return ErrInvalidLengthMapsproto2
5779 }
5780 postIndex := iNdEx + msglen
5781 if postIndex < 0 {
5782 return ErrInvalidLengthMapsproto2
5783 }
5784 if postIndex > l {
5785 return io.ErrUnexpectedEOF
5786 }
5787 if m.StringToBytesMap == nil {
5788 m.StringToBytesMap = make(map[string][]byte)
5789 }
5790 var mapkey string
5791 mapvalue := []byte{}
5792 for iNdEx < postIndex {
5793 entryPreIndex := iNdEx
5794 var wire uint64
5795 for shift := uint(0); ; shift += 7 {
5796 if shift >= 64 {
5797 return ErrIntOverflowMapsproto2
5798 }
5799 if iNdEx >= l {
5800 return io.ErrUnexpectedEOF
5801 }
5802 b := dAtA[iNdEx]
5803 iNdEx++
5804 wire |= uint64(b&0x7F) << shift
5805 if b < 0x80 {
5806 break
5807 }
5808 }
5809 fieldNum := int32(wire >> 3)
5810 if fieldNum == 1 {
5811 var stringLenmapkey uint64
5812 for shift := uint(0); ; shift += 7 {
5813 if shift >= 64 {
5814 return ErrIntOverflowMapsproto2
5815 }
5816 if iNdEx >= l {
5817 return io.ErrUnexpectedEOF
5818 }
5819 b := dAtA[iNdEx]
5820 iNdEx++
5821 stringLenmapkey |= uint64(b&0x7F) << shift
5822 if b < 0x80 {
5823 break
5824 }
5825 }
5826 intStringLenmapkey := int(stringLenmapkey)
5827 if intStringLenmapkey < 0 {
5828 return ErrInvalidLengthMapsproto2
5829 }
5830 postStringIndexmapkey := iNdEx + intStringLenmapkey
5831 if postStringIndexmapkey < 0 {
5832 return ErrInvalidLengthMapsproto2
5833 }
5834 if postStringIndexmapkey > l {
5835 return io.ErrUnexpectedEOF
5836 }
5837 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5838 iNdEx = postStringIndexmapkey
5839 } else if fieldNum == 2 {
5840 var mapbyteLen uint64
5841 for shift := uint(0); ; shift += 7 {
5842 if shift >= 64 {
5843 return ErrIntOverflowMapsproto2
5844 }
5845 if iNdEx >= l {
5846 return io.ErrUnexpectedEOF
5847 }
5848 b := dAtA[iNdEx]
5849 iNdEx++
5850 mapbyteLen |= uint64(b&0x7F) << shift
5851 if b < 0x80 {
5852 break
5853 }
5854 }
5855 intMapbyteLen := int(mapbyteLen)
5856 if intMapbyteLen < 0 {
5857 return ErrInvalidLengthMapsproto2
5858 }
5859 postbytesIndex := iNdEx + intMapbyteLen
5860 if postbytesIndex < 0 {
5861 return ErrInvalidLengthMapsproto2
5862 }
5863 if postbytesIndex > l {
5864 return io.ErrUnexpectedEOF
5865 }
5866 mapvalue = make([]byte, mapbyteLen)
5867 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
5868 iNdEx = postbytesIndex
5869 } else {
5870 iNdEx = entryPreIndex
5871 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5872 if err != nil {
5873 return err
5874 }
5875 if (skippy < 0) || (iNdEx+skippy) < 0 {
5876 return ErrInvalidLengthMapsproto2
5877 }
5878 if (iNdEx + skippy) > postIndex {
5879 return io.ErrUnexpectedEOF
5880 }
5881 iNdEx += skippy
5882 }
5883 }
5884 m.StringToBytesMap[mapkey] = mapvalue
5885 iNdEx = postIndex
5886 case 16:
5887 if wireType != 2 {
5888 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
5889 }
5890 var msglen int
5891 for shift := uint(0); ; shift += 7 {
5892 if shift >= 64 {
5893 return ErrIntOverflowMapsproto2
5894 }
5895 if iNdEx >= l {
5896 return io.ErrUnexpectedEOF
5897 }
5898 b := dAtA[iNdEx]
5899 iNdEx++
5900 msglen |= int(b&0x7F) << shift
5901 if b < 0x80 {
5902 break
5903 }
5904 }
5905 if msglen < 0 {
5906 return ErrInvalidLengthMapsproto2
5907 }
5908 postIndex := iNdEx + msglen
5909 if postIndex < 0 {
5910 return ErrInvalidLengthMapsproto2
5911 }
5912 if postIndex > l {
5913 return io.ErrUnexpectedEOF
5914 }
5915 if m.StringToEnumMap == nil {
5916 m.StringToEnumMap = make(map[string]MapEnum)
5917 }
5918 var mapkey string
5919 var mapvalue MapEnum
5920 for iNdEx < postIndex {
5921 entryPreIndex := iNdEx
5922 var wire uint64
5923 for shift := uint(0); ; shift += 7 {
5924 if shift >= 64 {
5925 return ErrIntOverflowMapsproto2
5926 }
5927 if iNdEx >= l {
5928 return io.ErrUnexpectedEOF
5929 }
5930 b := dAtA[iNdEx]
5931 iNdEx++
5932 wire |= uint64(b&0x7F) << shift
5933 if b < 0x80 {
5934 break
5935 }
5936 }
5937 fieldNum := int32(wire >> 3)
5938 if fieldNum == 1 {
5939 var stringLenmapkey uint64
5940 for shift := uint(0); ; shift += 7 {
5941 if shift >= 64 {
5942 return ErrIntOverflowMapsproto2
5943 }
5944 if iNdEx >= l {
5945 return io.ErrUnexpectedEOF
5946 }
5947 b := dAtA[iNdEx]
5948 iNdEx++
5949 stringLenmapkey |= uint64(b&0x7F) << shift
5950 if b < 0x80 {
5951 break
5952 }
5953 }
5954 intStringLenmapkey := int(stringLenmapkey)
5955 if intStringLenmapkey < 0 {
5956 return ErrInvalidLengthMapsproto2
5957 }
5958 postStringIndexmapkey := iNdEx + intStringLenmapkey
5959 if postStringIndexmapkey < 0 {
5960 return ErrInvalidLengthMapsproto2
5961 }
5962 if postStringIndexmapkey > l {
5963 return io.ErrUnexpectedEOF
5964 }
5965 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5966 iNdEx = postStringIndexmapkey
5967 } else if fieldNum == 2 {
5968 for shift := uint(0); ; shift += 7 {
5969 if shift >= 64 {
5970 return ErrIntOverflowMapsproto2
5971 }
5972 if iNdEx >= l {
5973 return io.ErrUnexpectedEOF
5974 }
5975 b := dAtA[iNdEx]
5976 iNdEx++
5977 mapvalue |= MapEnum(b&0x7F) << shift
5978 if b < 0x80 {
5979 break
5980 }
5981 }
5982 } else {
5983 iNdEx = entryPreIndex
5984 skippy, err := skipMapsproto2(dAtA[iNdEx:])
5985 if err != nil {
5986 return err
5987 }
5988 if (skippy < 0) || (iNdEx+skippy) < 0 {
5989 return ErrInvalidLengthMapsproto2
5990 }
5991 if (iNdEx + skippy) > postIndex {
5992 return io.ErrUnexpectedEOF
5993 }
5994 iNdEx += skippy
5995 }
5996 }
5997 m.StringToEnumMap[mapkey] = mapvalue
5998 iNdEx = postIndex
5999 case 17:
6000 if wireType != 2 {
6001 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
6002 }
6003 var msglen int
6004 for shift := uint(0); ; shift += 7 {
6005 if shift >= 64 {
6006 return ErrIntOverflowMapsproto2
6007 }
6008 if iNdEx >= l {
6009 return io.ErrUnexpectedEOF
6010 }
6011 b := dAtA[iNdEx]
6012 iNdEx++
6013 msglen |= int(b&0x7F) << shift
6014 if b < 0x80 {
6015 break
6016 }
6017 }
6018 if msglen < 0 {
6019 return ErrInvalidLengthMapsproto2
6020 }
6021 postIndex := iNdEx + msglen
6022 if postIndex < 0 {
6023 return ErrInvalidLengthMapsproto2
6024 }
6025 if postIndex > l {
6026 return io.ErrUnexpectedEOF
6027 }
6028 if m.StringToMsgMap == nil {
6029 m.StringToMsgMap = make(map[string]*FloatingPoint)
6030 }
6031 var mapkey string
6032 var mapvalue *FloatingPoint
6033 for iNdEx < postIndex {
6034 entryPreIndex := iNdEx
6035 var wire uint64
6036 for shift := uint(0); ; shift += 7 {
6037 if shift >= 64 {
6038 return ErrIntOverflowMapsproto2
6039 }
6040 if iNdEx >= l {
6041 return io.ErrUnexpectedEOF
6042 }
6043 b := dAtA[iNdEx]
6044 iNdEx++
6045 wire |= uint64(b&0x7F) << shift
6046 if b < 0x80 {
6047 break
6048 }
6049 }
6050 fieldNum := int32(wire >> 3)
6051 if fieldNum == 1 {
6052 var stringLenmapkey uint64
6053 for shift := uint(0); ; shift += 7 {
6054 if shift >= 64 {
6055 return ErrIntOverflowMapsproto2
6056 }
6057 if iNdEx >= l {
6058 return io.ErrUnexpectedEOF
6059 }
6060 b := dAtA[iNdEx]
6061 iNdEx++
6062 stringLenmapkey |= uint64(b&0x7F) << shift
6063 if b < 0x80 {
6064 break
6065 }
6066 }
6067 intStringLenmapkey := int(stringLenmapkey)
6068 if intStringLenmapkey < 0 {
6069 return ErrInvalidLengthMapsproto2
6070 }
6071 postStringIndexmapkey := iNdEx + intStringLenmapkey
6072 if postStringIndexmapkey < 0 {
6073 return ErrInvalidLengthMapsproto2
6074 }
6075 if postStringIndexmapkey > l {
6076 return io.ErrUnexpectedEOF
6077 }
6078 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6079 iNdEx = postStringIndexmapkey
6080 } else if fieldNum == 2 {
6081 var mapmsglen int
6082 for shift := uint(0); ; shift += 7 {
6083 if shift >= 64 {
6084 return ErrIntOverflowMapsproto2
6085 }
6086 if iNdEx >= l {
6087 return io.ErrUnexpectedEOF
6088 }
6089 b := dAtA[iNdEx]
6090 iNdEx++
6091 mapmsglen |= int(b&0x7F) << shift
6092 if b < 0x80 {
6093 break
6094 }
6095 }
6096 if mapmsglen < 0 {
6097 return ErrInvalidLengthMapsproto2
6098 }
6099 postmsgIndex := iNdEx + mapmsglen
6100 if postmsgIndex < 0 {
6101 return ErrInvalidLengthMapsproto2
6102 }
6103 if postmsgIndex > l {
6104 return io.ErrUnexpectedEOF
6105 }
6106 mapvalue = &FloatingPoint{}
6107 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
6108 return err
6109 }
6110 iNdEx = postmsgIndex
6111 } else {
6112 iNdEx = entryPreIndex
6113 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6114 if err != nil {
6115 return err
6116 }
6117 if (skippy < 0) || (iNdEx+skippy) < 0 {
6118 return ErrInvalidLengthMapsproto2
6119 }
6120 if (iNdEx + skippy) > postIndex {
6121 return io.ErrUnexpectedEOF
6122 }
6123 iNdEx += skippy
6124 }
6125 }
6126 m.StringToMsgMap[mapkey] = mapvalue
6127 iNdEx = postIndex
6128 default:
6129 iNdEx = preIndex
6130 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6131 if err != nil {
6132 return err
6133 }
6134 if (skippy < 0) || (iNdEx+skippy) < 0 {
6135 return ErrInvalidLengthMapsproto2
6136 }
6137 if (iNdEx + skippy) > l {
6138 return io.ErrUnexpectedEOF
6139 }
6140 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
6141 iNdEx += skippy
6142 }
6143 }
6144
6145 if iNdEx > l {
6146 return io.ErrUnexpectedEOF
6147 }
6148 return nil
6149 }
6150 func (m *AllMapsOrdered) Unmarshal(dAtA []byte) error {
6151 l := len(dAtA)
6152 iNdEx := 0
6153 for iNdEx < l {
6154 preIndex := iNdEx
6155 var wire uint64
6156 for shift := uint(0); ; shift += 7 {
6157 if shift >= 64 {
6158 return ErrIntOverflowMapsproto2
6159 }
6160 if iNdEx >= l {
6161 return io.ErrUnexpectedEOF
6162 }
6163 b := dAtA[iNdEx]
6164 iNdEx++
6165 wire |= uint64(b&0x7F) << shift
6166 if b < 0x80 {
6167 break
6168 }
6169 }
6170 fieldNum := int32(wire >> 3)
6171 wireType := int(wire & 0x7)
6172 if wireType == 4 {
6173 return fmt.Errorf("proto: AllMapsOrdered: wiretype end group for non-group")
6174 }
6175 if fieldNum <= 0 {
6176 return fmt.Errorf("proto: AllMapsOrdered: illegal tag %d (wire type %d)", fieldNum, wire)
6177 }
6178 switch fieldNum {
6179 case 1:
6180 if wireType != 2 {
6181 return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
6182 }
6183 var msglen int
6184 for shift := uint(0); ; shift += 7 {
6185 if shift >= 64 {
6186 return ErrIntOverflowMapsproto2
6187 }
6188 if iNdEx >= l {
6189 return io.ErrUnexpectedEOF
6190 }
6191 b := dAtA[iNdEx]
6192 iNdEx++
6193 msglen |= int(b&0x7F) << shift
6194 if b < 0x80 {
6195 break
6196 }
6197 }
6198 if msglen < 0 {
6199 return ErrInvalidLengthMapsproto2
6200 }
6201 postIndex := iNdEx + msglen
6202 if postIndex < 0 {
6203 return ErrInvalidLengthMapsproto2
6204 }
6205 if postIndex > l {
6206 return io.ErrUnexpectedEOF
6207 }
6208 if m.StringToDoubleMap == nil {
6209 m.StringToDoubleMap = make(map[string]float64)
6210 }
6211 var mapkey string
6212 var mapvalue float64
6213 for iNdEx < postIndex {
6214 entryPreIndex := iNdEx
6215 var wire uint64
6216 for shift := uint(0); ; shift += 7 {
6217 if shift >= 64 {
6218 return ErrIntOverflowMapsproto2
6219 }
6220 if iNdEx >= l {
6221 return io.ErrUnexpectedEOF
6222 }
6223 b := dAtA[iNdEx]
6224 iNdEx++
6225 wire |= uint64(b&0x7F) << shift
6226 if b < 0x80 {
6227 break
6228 }
6229 }
6230 fieldNum := int32(wire >> 3)
6231 if fieldNum == 1 {
6232 var stringLenmapkey uint64
6233 for shift := uint(0); ; shift += 7 {
6234 if shift >= 64 {
6235 return ErrIntOverflowMapsproto2
6236 }
6237 if iNdEx >= l {
6238 return io.ErrUnexpectedEOF
6239 }
6240 b := dAtA[iNdEx]
6241 iNdEx++
6242 stringLenmapkey |= uint64(b&0x7F) << shift
6243 if b < 0x80 {
6244 break
6245 }
6246 }
6247 intStringLenmapkey := int(stringLenmapkey)
6248 if intStringLenmapkey < 0 {
6249 return ErrInvalidLengthMapsproto2
6250 }
6251 postStringIndexmapkey := iNdEx + intStringLenmapkey
6252 if postStringIndexmapkey < 0 {
6253 return ErrInvalidLengthMapsproto2
6254 }
6255 if postStringIndexmapkey > l {
6256 return io.ErrUnexpectedEOF
6257 }
6258 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6259 iNdEx = postStringIndexmapkey
6260 } else if fieldNum == 2 {
6261 var mapvaluetemp uint64
6262 if (iNdEx + 8) > l {
6263 return io.ErrUnexpectedEOF
6264 }
6265 mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
6266 iNdEx += 8
6267 mapvalue = math.Float64frombits(mapvaluetemp)
6268 } else {
6269 iNdEx = entryPreIndex
6270 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6271 if err != nil {
6272 return err
6273 }
6274 if (skippy < 0) || (iNdEx+skippy) < 0 {
6275 return ErrInvalidLengthMapsproto2
6276 }
6277 if (iNdEx + skippy) > postIndex {
6278 return io.ErrUnexpectedEOF
6279 }
6280 iNdEx += skippy
6281 }
6282 }
6283 m.StringToDoubleMap[mapkey] = mapvalue
6284 iNdEx = postIndex
6285 case 2:
6286 if wireType != 2 {
6287 return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
6288 }
6289 var msglen int
6290 for shift := uint(0); ; shift += 7 {
6291 if shift >= 64 {
6292 return ErrIntOverflowMapsproto2
6293 }
6294 if iNdEx >= l {
6295 return io.ErrUnexpectedEOF
6296 }
6297 b := dAtA[iNdEx]
6298 iNdEx++
6299 msglen |= int(b&0x7F) << shift
6300 if b < 0x80 {
6301 break
6302 }
6303 }
6304 if msglen < 0 {
6305 return ErrInvalidLengthMapsproto2
6306 }
6307 postIndex := iNdEx + msglen
6308 if postIndex < 0 {
6309 return ErrInvalidLengthMapsproto2
6310 }
6311 if postIndex > l {
6312 return io.ErrUnexpectedEOF
6313 }
6314 if m.StringToFloatMap == nil {
6315 m.StringToFloatMap = make(map[string]float32)
6316 }
6317 var mapkey string
6318 var mapvalue float32
6319 for iNdEx < postIndex {
6320 entryPreIndex := iNdEx
6321 var wire uint64
6322 for shift := uint(0); ; shift += 7 {
6323 if shift >= 64 {
6324 return ErrIntOverflowMapsproto2
6325 }
6326 if iNdEx >= l {
6327 return io.ErrUnexpectedEOF
6328 }
6329 b := dAtA[iNdEx]
6330 iNdEx++
6331 wire |= uint64(b&0x7F) << shift
6332 if b < 0x80 {
6333 break
6334 }
6335 }
6336 fieldNum := int32(wire >> 3)
6337 if fieldNum == 1 {
6338 var stringLenmapkey uint64
6339 for shift := uint(0); ; shift += 7 {
6340 if shift >= 64 {
6341 return ErrIntOverflowMapsproto2
6342 }
6343 if iNdEx >= l {
6344 return io.ErrUnexpectedEOF
6345 }
6346 b := dAtA[iNdEx]
6347 iNdEx++
6348 stringLenmapkey |= uint64(b&0x7F) << shift
6349 if b < 0x80 {
6350 break
6351 }
6352 }
6353 intStringLenmapkey := int(stringLenmapkey)
6354 if intStringLenmapkey < 0 {
6355 return ErrInvalidLengthMapsproto2
6356 }
6357 postStringIndexmapkey := iNdEx + intStringLenmapkey
6358 if postStringIndexmapkey < 0 {
6359 return ErrInvalidLengthMapsproto2
6360 }
6361 if postStringIndexmapkey > l {
6362 return io.ErrUnexpectedEOF
6363 }
6364 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6365 iNdEx = postStringIndexmapkey
6366 } else if fieldNum == 2 {
6367 var mapvaluetemp uint32
6368 if (iNdEx + 4) > l {
6369 return io.ErrUnexpectedEOF
6370 }
6371 mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
6372 iNdEx += 4
6373 mapvalue = math.Float32frombits(mapvaluetemp)
6374 } else {
6375 iNdEx = entryPreIndex
6376 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6377 if err != nil {
6378 return err
6379 }
6380 if (skippy < 0) || (iNdEx+skippy) < 0 {
6381 return ErrInvalidLengthMapsproto2
6382 }
6383 if (iNdEx + skippy) > postIndex {
6384 return io.ErrUnexpectedEOF
6385 }
6386 iNdEx += skippy
6387 }
6388 }
6389 m.StringToFloatMap[mapkey] = mapvalue
6390 iNdEx = postIndex
6391 case 3:
6392 if wireType != 2 {
6393 return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
6394 }
6395 var msglen int
6396 for shift := uint(0); ; shift += 7 {
6397 if shift >= 64 {
6398 return ErrIntOverflowMapsproto2
6399 }
6400 if iNdEx >= l {
6401 return io.ErrUnexpectedEOF
6402 }
6403 b := dAtA[iNdEx]
6404 iNdEx++
6405 msglen |= int(b&0x7F) << shift
6406 if b < 0x80 {
6407 break
6408 }
6409 }
6410 if msglen < 0 {
6411 return ErrInvalidLengthMapsproto2
6412 }
6413 postIndex := iNdEx + msglen
6414 if postIndex < 0 {
6415 return ErrInvalidLengthMapsproto2
6416 }
6417 if postIndex > l {
6418 return io.ErrUnexpectedEOF
6419 }
6420 if m.Int32Map == nil {
6421 m.Int32Map = make(map[int32]int32)
6422 }
6423 var mapkey int32
6424 var mapvalue int32
6425 for iNdEx < postIndex {
6426 entryPreIndex := iNdEx
6427 var wire uint64
6428 for shift := uint(0); ; shift += 7 {
6429 if shift >= 64 {
6430 return ErrIntOverflowMapsproto2
6431 }
6432 if iNdEx >= l {
6433 return io.ErrUnexpectedEOF
6434 }
6435 b := dAtA[iNdEx]
6436 iNdEx++
6437 wire |= uint64(b&0x7F) << shift
6438 if b < 0x80 {
6439 break
6440 }
6441 }
6442 fieldNum := int32(wire >> 3)
6443 if fieldNum == 1 {
6444 for shift := uint(0); ; shift += 7 {
6445 if shift >= 64 {
6446 return ErrIntOverflowMapsproto2
6447 }
6448 if iNdEx >= l {
6449 return io.ErrUnexpectedEOF
6450 }
6451 b := dAtA[iNdEx]
6452 iNdEx++
6453 mapkey |= int32(b&0x7F) << shift
6454 if b < 0x80 {
6455 break
6456 }
6457 }
6458 } else if fieldNum == 2 {
6459 for shift := uint(0); ; shift += 7 {
6460 if shift >= 64 {
6461 return ErrIntOverflowMapsproto2
6462 }
6463 if iNdEx >= l {
6464 return io.ErrUnexpectedEOF
6465 }
6466 b := dAtA[iNdEx]
6467 iNdEx++
6468 mapvalue |= int32(b&0x7F) << shift
6469 if b < 0x80 {
6470 break
6471 }
6472 }
6473 } else {
6474 iNdEx = entryPreIndex
6475 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6476 if err != nil {
6477 return err
6478 }
6479 if (skippy < 0) || (iNdEx+skippy) < 0 {
6480 return ErrInvalidLengthMapsproto2
6481 }
6482 if (iNdEx + skippy) > postIndex {
6483 return io.ErrUnexpectedEOF
6484 }
6485 iNdEx += skippy
6486 }
6487 }
6488 m.Int32Map[mapkey] = mapvalue
6489 iNdEx = postIndex
6490 case 4:
6491 if wireType != 2 {
6492 return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
6493 }
6494 var msglen int
6495 for shift := uint(0); ; shift += 7 {
6496 if shift >= 64 {
6497 return ErrIntOverflowMapsproto2
6498 }
6499 if iNdEx >= l {
6500 return io.ErrUnexpectedEOF
6501 }
6502 b := dAtA[iNdEx]
6503 iNdEx++
6504 msglen |= int(b&0x7F) << shift
6505 if b < 0x80 {
6506 break
6507 }
6508 }
6509 if msglen < 0 {
6510 return ErrInvalidLengthMapsproto2
6511 }
6512 postIndex := iNdEx + msglen
6513 if postIndex < 0 {
6514 return ErrInvalidLengthMapsproto2
6515 }
6516 if postIndex > l {
6517 return io.ErrUnexpectedEOF
6518 }
6519 if m.Int64Map == nil {
6520 m.Int64Map = make(map[int64]int64)
6521 }
6522 var mapkey int64
6523 var mapvalue int64
6524 for iNdEx < postIndex {
6525 entryPreIndex := iNdEx
6526 var wire uint64
6527 for shift := uint(0); ; shift += 7 {
6528 if shift >= 64 {
6529 return ErrIntOverflowMapsproto2
6530 }
6531 if iNdEx >= l {
6532 return io.ErrUnexpectedEOF
6533 }
6534 b := dAtA[iNdEx]
6535 iNdEx++
6536 wire |= uint64(b&0x7F) << shift
6537 if b < 0x80 {
6538 break
6539 }
6540 }
6541 fieldNum := int32(wire >> 3)
6542 if fieldNum == 1 {
6543 for shift := uint(0); ; shift += 7 {
6544 if shift >= 64 {
6545 return ErrIntOverflowMapsproto2
6546 }
6547 if iNdEx >= l {
6548 return io.ErrUnexpectedEOF
6549 }
6550 b := dAtA[iNdEx]
6551 iNdEx++
6552 mapkey |= int64(b&0x7F) << shift
6553 if b < 0x80 {
6554 break
6555 }
6556 }
6557 } else if fieldNum == 2 {
6558 for shift := uint(0); ; shift += 7 {
6559 if shift >= 64 {
6560 return ErrIntOverflowMapsproto2
6561 }
6562 if iNdEx >= l {
6563 return io.ErrUnexpectedEOF
6564 }
6565 b := dAtA[iNdEx]
6566 iNdEx++
6567 mapvalue |= int64(b&0x7F) << shift
6568 if b < 0x80 {
6569 break
6570 }
6571 }
6572 } else {
6573 iNdEx = entryPreIndex
6574 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6575 if err != nil {
6576 return err
6577 }
6578 if (skippy < 0) || (iNdEx+skippy) < 0 {
6579 return ErrInvalidLengthMapsproto2
6580 }
6581 if (iNdEx + skippy) > postIndex {
6582 return io.ErrUnexpectedEOF
6583 }
6584 iNdEx += skippy
6585 }
6586 }
6587 m.Int64Map[mapkey] = mapvalue
6588 iNdEx = postIndex
6589 case 5:
6590 if wireType != 2 {
6591 return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
6592 }
6593 var msglen int
6594 for shift := uint(0); ; shift += 7 {
6595 if shift >= 64 {
6596 return ErrIntOverflowMapsproto2
6597 }
6598 if iNdEx >= l {
6599 return io.ErrUnexpectedEOF
6600 }
6601 b := dAtA[iNdEx]
6602 iNdEx++
6603 msglen |= int(b&0x7F) << shift
6604 if b < 0x80 {
6605 break
6606 }
6607 }
6608 if msglen < 0 {
6609 return ErrInvalidLengthMapsproto2
6610 }
6611 postIndex := iNdEx + msglen
6612 if postIndex < 0 {
6613 return ErrInvalidLengthMapsproto2
6614 }
6615 if postIndex > l {
6616 return io.ErrUnexpectedEOF
6617 }
6618 if m.Uint32Map == nil {
6619 m.Uint32Map = make(map[uint32]uint32)
6620 }
6621 var mapkey uint32
6622 var mapvalue uint32
6623 for iNdEx < postIndex {
6624 entryPreIndex := iNdEx
6625 var wire uint64
6626 for shift := uint(0); ; shift += 7 {
6627 if shift >= 64 {
6628 return ErrIntOverflowMapsproto2
6629 }
6630 if iNdEx >= l {
6631 return io.ErrUnexpectedEOF
6632 }
6633 b := dAtA[iNdEx]
6634 iNdEx++
6635 wire |= uint64(b&0x7F) << shift
6636 if b < 0x80 {
6637 break
6638 }
6639 }
6640 fieldNum := int32(wire >> 3)
6641 if fieldNum == 1 {
6642 for shift := uint(0); ; shift += 7 {
6643 if shift >= 64 {
6644 return ErrIntOverflowMapsproto2
6645 }
6646 if iNdEx >= l {
6647 return io.ErrUnexpectedEOF
6648 }
6649 b := dAtA[iNdEx]
6650 iNdEx++
6651 mapkey |= uint32(b&0x7F) << shift
6652 if b < 0x80 {
6653 break
6654 }
6655 }
6656 } else if fieldNum == 2 {
6657 for shift := uint(0); ; shift += 7 {
6658 if shift >= 64 {
6659 return ErrIntOverflowMapsproto2
6660 }
6661 if iNdEx >= l {
6662 return io.ErrUnexpectedEOF
6663 }
6664 b := dAtA[iNdEx]
6665 iNdEx++
6666 mapvalue |= uint32(b&0x7F) << shift
6667 if b < 0x80 {
6668 break
6669 }
6670 }
6671 } else {
6672 iNdEx = entryPreIndex
6673 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6674 if err != nil {
6675 return err
6676 }
6677 if (skippy < 0) || (iNdEx+skippy) < 0 {
6678 return ErrInvalidLengthMapsproto2
6679 }
6680 if (iNdEx + skippy) > postIndex {
6681 return io.ErrUnexpectedEOF
6682 }
6683 iNdEx += skippy
6684 }
6685 }
6686 m.Uint32Map[mapkey] = mapvalue
6687 iNdEx = postIndex
6688 case 6:
6689 if wireType != 2 {
6690 return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
6691 }
6692 var msglen int
6693 for shift := uint(0); ; shift += 7 {
6694 if shift >= 64 {
6695 return ErrIntOverflowMapsproto2
6696 }
6697 if iNdEx >= l {
6698 return io.ErrUnexpectedEOF
6699 }
6700 b := dAtA[iNdEx]
6701 iNdEx++
6702 msglen |= int(b&0x7F) << shift
6703 if b < 0x80 {
6704 break
6705 }
6706 }
6707 if msglen < 0 {
6708 return ErrInvalidLengthMapsproto2
6709 }
6710 postIndex := iNdEx + msglen
6711 if postIndex < 0 {
6712 return ErrInvalidLengthMapsproto2
6713 }
6714 if postIndex > l {
6715 return io.ErrUnexpectedEOF
6716 }
6717 if m.Uint64Map == nil {
6718 m.Uint64Map = make(map[uint64]uint64)
6719 }
6720 var mapkey uint64
6721 var mapvalue uint64
6722 for iNdEx < postIndex {
6723 entryPreIndex := iNdEx
6724 var wire uint64
6725 for shift := uint(0); ; shift += 7 {
6726 if shift >= 64 {
6727 return ErrIntOverflowMapsproto2
6728 }
6729 if iNdEx >= l {
6730 return io.ErrUnexpectedEOF
6731 }
6732 b := dAtA[iNdEx]
6733 iNdEx++
6734 wire |= uint64(b&0x7F) << shift
6735 if b < 0x80 {
6736 break
6737 }
6738 }
6739 fieldNum := int32(wire >> 3)
6740 if fieldNum == 1 {
6741 for shift := uint(0); ; shift += 7 {
6742 if shift >= 64 {
6743 return ErrIntOverflowMapsproto2
6744 }
6745 if iNdEx >= l {
6746 return io.ErrUnexpectedEOF
6747 }
6748 b := dAtA[iNdEx]
6749 iNdEx++
6750 mapkey |= uint64(b&0x7F) << shift
6751 if b < 0x80 {
6752 break
6753 }
6754 }
6755 } else if fieldNum == 2 {
6756 for shift := uint(0); ; shift += 7 {
6757 if shift >= 64 {
6758 return ErrIntOverflowMapsproto2
6759 }
6760 if iNdEx >= l {
6761 return io.ErrUnexpectedEOF
6762 }
6763 b := dAtA[iNdEx]
6764 iNdEx++
6765 mapvalue |= uint64(b&0x7F) << shift
6766 if b < 0x80 {
6767 break
6768 }
6769 }
6770 } else {
6771 iNdEx = entryPreIndex
6772 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6773 if err != nil {
6774 return err
6775 }
6776 if (skippy < 0) || (iNdEx+skippy) < 0 {
6777 return ErrInvalidLengthMapsproto2
6778 }
6779 if (iNdEx + skippy) > postIndex {
6780 return io.ErrUnexpectedEOF
6781 }
6782 iNdEx += skippy
6783 }
6784 }
6785 m.Uint64Map[mapkey] = mapvalue
6786 iNdEx = postIndex
6787 case 7:
6788 if wireType != 2 {
6789 return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
6790 }
6791 var msglen int
6792 for shift := uint(0); ; shift += 7 {
6793 if shift >= 64 {
6794 return ErrIntOverflowMapsproto2
6795 }
6796 if iNdEx >= l {
6797 return io.ErrUnexpectedEOF
6798 }
6799 b := dAtA[iNdEx]
6800 iNdEx++
6801 msglen |= int(b&0x7F) << shift
6802 if b < 0x80 {
6803 break
6804 }
6805 }
6806 if msglen < 0 {
6807 return ErrInvalidLengthMapsproto2
6808 }
6809 postIndex := iNdEx + msglen
6810 if postIndex < 0 {
6811 return ErrInvalidLengthMapsproto2
6812 }
6813 if postIndex > l {
6814 return io.ErrUnexpectedEOF
6815 }
6816 if m.Sint32Map == nil {
6817 m.Sint32Map = make(map[int32]int32)
6818 }
6819 var mapkey int32
6820 var mapvalue int32
6821 for iNdEx < postIndex {
6822 entryPreIndex := iNdEx
6823 var wire uint64
6824 for shift := uint(0); ; shift += 7 {
6825 if shift >= 64 {
6826 return ErrIntOverflowMapsproto2
6827 }
6828 if iNdEx >= l {
6829 return io.ErrUnexpectedEOF
6830 }
6831 b := dAtA[iNdEx]
6832 iNdEx++
6833 wire |= uint64(b&0x7F) << shift
6834 if b < 0x80 {
6835 break
6836 }
6837 }
6838 fieldNum := int32(wire >> 3)
6839 if fieldNum == 1 {
6840 var mapkeytemp int32
6841 for shift := uint(0); ; shift += 7 {
6842 if shift >= 64 {
6843 return ErrIntOverflowMapsproto2
6844 }
6845 if iNdEx >= l {
6846 return io.ErrUnexpectedEOF
6847 }
6848 b := dAtA[iNdEx]
6849 iNdEx++
6850 mapkeytemp |= int32(b&0x7F) << shift
6851 if b < 0x80 {
6852 break
6853 }
6854 }
6855 mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
6856 mapkey = int32(mapkeytemp)
6857 } else if fieldNum == 2 {
6858 var mapvaluetemp int32
6859 for shift := uint(0); ; shift += 7 {
6860 if shift >= 64 {
6861 return ErrIntOverflowMapsproto2
6862 }
6863 if iNdEx >= l {
6864 return io.ErrUnexpectedEOF
6865 }
6866 b := dAtA[iNdEx]
6867 iNdEx++
6868 mapvaluetemp |= int32(b&0x7F) << shift
6869 if b < 0x80 {
6870 break
6871 }
6872 }
6873 mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
6874 mapvalue = int32(mapvaluetemp)
6875 } else {
6876 iNdEx = entryPreIndex
6877 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6878 if err != nil {
6879 return err
6880 }
6881 if (skippy < 0) || (iNdEx+skippy) < 0 {
6882 return ErrInvalidLengthMapsproto2
6883 }
6884 if (iNdEx + skippy) > postIndex {
6885 return io.ErrUnexpectedEOF
6886 }
6887 iNdEx += skippy
6888 }
6889 }
6890 m.Sint32Map[mapkey] = mapvalue
6891 iNdEx = postIndex
6892 case 8:
6893 if wireType != 2 {
6894 return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
6895 }
6896 var msglen int
6897 for shift := uint(0); ; shift += 7 {
6898 if shift >= 64 {
6899 return ErrIntOverflowMapsproto2
6900 }
6901 if iNdEx >= l {
6902 return io.ErrUnexpectedEOF
6903 }
6904 b := dAtA[iNdEx]
6905 iNdEx++
6906 msglen |= int(b&0x7F) << shift
6907 if b < 0x80 {
6908 break
6909 }
6910 }
6911 if msglen < 0 {
6912 return ErrInvalidLengthMapsproto2
6913 }
6914 postIndex := iNdEx + msglen
6915 if postIndex < 0 {
6916 return ErrInvalidLengthMapsproto2
6917 }
6918 if postIndex > l {
6919 return io.ErrUnexpectedEOF
6920 }
6921 if m.Sint64Map == nil {
6922 m.Sint64Map = make(map[int64]int64)
6923 }
6924 var mapkey int64
6925 var mapvalue int64
6926 for iNdEx < postIndex {
6927 entryPreIndex := iNdEx
6928 var wire uint64
6929 for shift := uint(0); ; shift += 7 {
6930 if shift >= 64 {
6931 return ErrIntOverflowMapsproto2
6932 }
6933 if iNdEx >= l {
6934 return io.ErrUnexpectedEOF
6935 }
6936 b := dAtA[iNdEx]
6937 iNdEx++
6938 wire |= uint64(b&0x7F) << shift
6939 if b < 0x80 {
6940 break
6941 }
6942 }
6943 fieldNum := int32(wire >> 3)
6944 if fieldNum == 1 {
6945 var mapkeytemp uint64
6946 for shift := uint(0); ; shift += 7 {
6947 if shift >= 64 {
6948 return ErrIntOverflowMapsproto2
6949 }
6950 if iNdEx >= l {
6951 return io.ErrUnexpectedEOF
6952 }
6953 b := dAtA[iNdEx]
6954 iNdEx++
6955 mapkeytemp |= uint64(b&0x7F) << shift
6956 if b < 0x80 {
6957 break
6958 }
6959 }
6960 mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
6961 mapkey = int64(mapkeytemp)
6962 } else if fieldNum == 2 {
6963 var mapvaluetemp uint64
6964 for shift := uint(0); ; shift += 7 {
6965 if shift >= 64 {
6966 return ErrIntOverflowMapsproto2
6967 }
6968 if iNdEx >= l {
6969 return io.ErrUnexpectedEOF
6970 }
6971 b := dAtA[iNdEx]
6972 iNdEx++
6973 mapvaluetemp |= uint64(b&0x7F) << shift
6974 if b < 0x80 {
6975 break
6976 }
6977 }
6978 mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
6979 mapvalue = int64(mapvaluetemp)
6980 } else {
6981 iNdEx = entryPreIndex
6982 skippy, err := skipMapsproto2(dAtA[iNdEx:])
6983 if err != nil {
6984 return err
6985 }
6986 if (skippy < 0) || (iNdEx+skippy) < 0 {
6987 return ErrInvalidLengthMapsproto2
6988 }
6989 if (iNdEx + skippy) > postIndex {
6990 return io.ErrUnexpectedEOF
6991 }
6992 iNdEx += skippy
6993 }
6994 }
6995 m.Sint64Map[mapkey] = mapvalue
6996 iNdEx = postIndex
6997 case 9:
6998 if wireType != 2 {
6999 return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
7000 }
7001 var msglen int
7002 for shift := uint(0); ; shift += 7 {
7003 if shift >= 64 {
7004 return ErrIntOverflowMapsproto2
7005 }
7006 if iNdEx >= l {
7007 return io.ErrUnexpectedEOF
7008 }
7009 b := dAtA[iNdEx]
7010 iNdEx++
7011 msglen |= int(b&0x7F) << shift
7012 if b < 0x80 {
7013 break
7014 }
7015 }
7016 if msglen < 0 {
7017 return ErrInvalidLengthMapsproto2
7018 }
7019 postIndex := iNdEx + msglen
7020 if postIndex < 0 {
7021 return ErrInvalidLengthMapsproto2
7022 }
7023 if postIndex > l {
7024 return io.ErrUnexpectedEOF
7025 }
7026 if m.Fixed32Map == nil {
7027 m.Fixed32Map = make(map[uint32]uint32)
7028 }
7029 var mapkey uint32
7030 var mapvalue uint32
7031 for iNdEx < postIndex {
7032 entryPreIndex := iNdEx
7033 var wire uint64
7034 for shift := uint(0); ; shift += 7 {
7035 if shift >= 64 {
7036 return ErrIntOverflowMapsproto2
7037 }
7038 if iNdEx >= l {
7039 return io.ErrUnexpectedEOF
7040 }
7041 b := dAtA[iNdEx]
7042 iNdEx++
7043 wire |= uint64(b&0x7F) << shift
7044 if b < 0x80 {
7045 break
7046 }
7047 }
7048 fieldNum := int32(wire >> 3)
7049 if fieldNum == 1 {
7050 if (iNdEx + 4) > l {
7051 return io.ErrUnexpectedEOF
7052 }
7053 mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7054 iNdEx += 4
7055 } else if fieldNum == 2 {
7056 if (iNdEx + 4) > l {
7057 return io.ErrUnexpectedEOF
7058 }
7059 mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7060 iNdEx += 4
7061 } else {
7062 iNdEx = entryPreIndex
7063 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7064 if err != nil {
7065 return err
7066 }
7067 if (skippy < 0) || (iNdEx+skippy) < 0 {
7068 return ErrInvalidLengthMapsproto2
7069 }
7070 if (iNdEx + skippy) > postIndex {
7071 return io.ErrUnexpectedEOF
7072 }
7073 iNdEx += skippy
7074 }
7075 }
7076 m.Fixed32Map[mapkey] = mapvalue
7077 iNdEx = postIndex
7078 case 10:
7079 if wireType != 2 {
7080 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
7081 }
7082 var msglen int
7083 for shift := uint(0); ; shift += 7 {
7084 if shift >= 64 {
7085 return ErrIntOverflowMapsproto2
7086 }
7087 if iNdEx >= l {
7088 return io.ErrUnexpectedEOF
7089 }
7090 b := dAtA[iNdEx]
7091 iNdEx++
7092 msglen |= int(b&0x7F) << shift
7093 if b < 0x80 {
7094 break
7095 }
7096 }
7097 if msglen < 0 {
7098 return ErrInvalidLengthMapsproto2
7099 }
7100 postIndex := iNdEx + msglen
7101 if postIndex < 0 {
7102 return ErrInvalidLengthMapsproto2
7103 }
7104 if postIndex > l {
7105 return io.ErrUnexpectedEOF
7106 }
7107 if m.Sfixed32Map == nil {
7108 m.Sfixed32Map = make(map[int32]int32)
7109 }
7110 var mapkey int32
7111 var mapvalue int32
7112 for iNdEx < postIndex {
7113 entryPreIndex := iNdEx
7114 var wire uint64
7115 for shift := uint(0); ; shift += 7 {
7116 if shift >= 64 {
7117 return ErrIntOverflowMapsproto2
7118 }
7119 if iNdEx >= l {
7120 return io.ErrUnexpectedEOF
7121 }
7122 b := dAtA[iNdEx]
7123 iNdEx++
7124 wire |= uint64(b&0x7F) << shift
7125 if b < 0x80 {
7126 break
7127 }
7128 }
7129 fieldNum := int32(wire >> 3)
7130 if fieldNum == 1 {
7131 if (iNdEx + 4) > l {
7132 return io.ErrUnexpectedEOF
7133 }
7134 mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7135 iNdEx += 4
7136 } else if fieldNum == 2 {
7137 if (iNdEx + 4) > l {
7138 return io.ErrUnexpectedEOF
7139 }
7140 mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
7141 iNdEx += 4
7142 } else {
7143 iNdEx = entryPreIndex
7144 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7145 if err != nil {
7146 return err
7147 }
7148 if (skippy < 0) || (iNdEx+skippy) < 0 {
7149 return ErrInvalidLengthMapsproto2
7150 }
7151 if (iNdEx + skippy) > postIndex {
7152 return io.ErrUnexpectedEOF
7153 }
7154 iNdEx += skippy
7155 }
7156 }
7157 m.Sfixed32Map[mapkey] = mapvalue
7158 iNdEx = postIndex
7159 case 11:
7160 if wireType != 2 {
7161 return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
7162 }
7163 var msglen int
7164 for shift := uint(0); ; shift += 7 {
7165 if shift >= 64 {
7166 return ErrIntOverflowMapsproto2
7167 }
7168 if iNdEx >= l {
7169 return io.ErrUnexpectedEOF
7170 }
7171 b := dAtA[iNdEx]
7172 iNdEx++
7173 msglen |= int(b&0x7F) << shift
7174 if b < 0x80 {
7175 break
7176 }
7177 }
7178 if msglen < 0 {
7179 return ErrInvalidLengthMapsproto2
7180 }
7181 postIndex := iNdEx + msglen
7182 if postIndex < 0 {
7183 return ErrInvalidLengthMapsproto2
7184 }
7185 if postIndex > l {
7186 return io.ErrUnexpectedEOF
7187 }
7188 if m.Fixed64Map == nil {
7189 m.Fixed64Map = make(map[uint64]uint64)
7190 }
7191 var mapkey uint64
7192 var mapvalue uint64
7193 for iNdEx < postIndex {
7194 entryPreIndex := iNdEx
7195 var wire uint64
7196 for shift := uint(0); ; shift += 7 {
7197 if shift >= 64 {
7198 return ErrIntOverflowMapsproto2
7199 }
7200 if iNdEx >= l {
7201 return io.ErrUnexpectedEOF
7202 }
7203 b := dAtA[iNdEx]
7204 iNdEx++
7205 wire |= uint64(b&0x7F) << shift
7206 if b < 0x80 {
7207 break
7208 }
7209 }
7210 fieldNum := int32(wire >> 3)
7211 if fieldNum == 1 {
7212 if (iNdEx + 8) > l {
7213 return io.ErrUnexpectedEOF
7214 }
7215 mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7216 iNdEx += 8
7217 } else if fieldNum == 2 {
7218 if (iNdEx + 8) > l {
7219 return io.ErrUnexpectedEOF
7220 }
7221 mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7222 iNdEx += 8
7223 } else {
7224 iNdEx = entryPreIndex
7225 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7226 if err != nil {
7227 return err
7228 }
7229 if (skippy < 0) || (iNdEx+skippy) < 0 {
7230 return ErrInvalidLengthMapsproto2
7231 }
7232 if (iNdEx + skippy) > postIndex {
7233 return io.ErrUnexpectedEOF
7234 }
7235 iNdEx += skippy
7236 }
7237 }
7238 m.Fixed64Map[mapkey] = mapvalue
7239 iNdEx = postIndex
7240 case 12:
7241 if wireType != 2 {
7242 return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
7243 }
7244 var msglen int
7245 for shift := uint(0); ; shift += 7 {
7246 if shift >= 64 {
7247 return ErrIntOverflowMapsproto2
7248 }
7249 if iNdEx >= l {
7250 return io.ErrUnexpectedEOF
7251 }
7252 b := dAtA[iNdEx]
7253 iNdEx++
7254 msglen |= int(b&0x7F) << shift
7255 if b < 0x80 {
7256 break
7257 }
7258 }
7259 if msglen < 0 {
7260 return ErrInvalidLengthMapsproto2
7261 }
7262 postIndex := iNdEx + msglen
7263 if postIndex < 0 {
7264 return ErrInvalidLengthMapsproto2
7265 }
7266 if postIndex > l {
7267 return io.ErrUnexpectedEOF
7268 }
7269 if m.Sfixed64Map == nil {
7270 m.Sfixed64Map = make(map[int64]int64)
7271 }
7272 var mapkey int64
7273 var mapvalue int64
7274 for iNdEx < postIndex {
7275 entryPreIndex := iNdEx
7276 var wire uint64
7277 for shift := uint(0); ; shift += 7 {
7278 if shift >= 64 {
7279 return ErrIntOverflowMapsproto2
7280 }
7281 if iNdEx >= l {
7282 return io.ErrUnexpectedEOF
7283 }
7284 b := dAtA[iNdEx]
7285 iNdEx++
7286 wire |= uint64(b&0x7F) << shift
7287 if b < 0x80 {
7288 break
7289 }
7290 }
7291 fieldNum := int32(wire >> 3)
7292 if fieldNum == 1 {
7293 if (iNdEx + 8) > l {
7294 return io.ErrUnexpectedEOF
7295 }
7296 mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7297 iNdEx += 8
7298 } else if fieldNum == 2 {
7299 if (iNdEx + 8) > l {
7300 return io.ErrUnexpectedEOF
7301 }
7302 mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
7303 iNdEx += 8
7304 } else {
7305 iNdEx = entryPreIndex
7306 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7307 if err != nil {
7308 return err
7309 }
7310 if (skippy < 0) || (iNdEx+skippy) < 0 {
7311 return ErrInvalidLengthMapsproto2
7312 }
7313 if (iNdEx + skippy) > postIndex {
7314 return io.ErrUnexpectedEOF
7315 }
7316 iNdEx += skippy
7317 }
7318 }
7319 m.Sfixed64Map[mapkey] = mapvalue
7320 iNdEx = postIndex
7321 case 13:
7322 if wireType != 2 {
7323 return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
7324 }
7325 var msglen int
7326 for shift := uint(0); ; shift += 7 {
7327 if shift >= 64 {
7328 return ErrIntOverflowMapsproto2
7329 }
7330 if iNdEx >= l {
7331 return io.ErrUnexpectedEOF
7332 }
7333 b := dAtA[iNdEx]
7334 iNdEx++
7335 msglen |= int(b&0x7F) << shift
7336 if b < 0x80 {
7337 break
7338 }
7339 }
7340 if msglen < 0 {
7341 return ErrInvalidLengthMapsproto2
7342 }
7343 postIndex := iNdEx + msglen
7344 if postIndex < 0 {
7345 return ErrInvalidLengthMapsproto2
7346 }
7347 if postIndex > l {
7348 return io.ErrUnexpectedEOF
7349 }
7350 if m.BoolMap == nil {
7351 m.BoolMap = make(map[bool]bool)
7352 }
7353 var mapkey bool
7354 var mapvalue bool
7355 for iNdEx < postIndex {
7356 entryPreIndex := iNdEx
7357 var wire uint64
7358 for shift := uint(0); ; shift += 7 {
7359 if shift >= 64 {
7360 return ErrIntOverflowMapsproto2
7361 }
7362 if iNdEx >= l {
7363 return io.ErrUnexpectedEOF
7364 }
7365 b := dAtA[iNdEx]
7366 iNdEx++
7367 wire |= uint64(b&0x7F) << shift
7368 if b < 0x80 {
7369 break
7370 }
7371 }
7372 fieldNum := int32(wire >> 3)
7373 if fieldNum == 1 {
7374 var mapkeytemp int
7375 for shift := uint(0); ; shift += 7 {
7376 if shift >= 64 {
7377 return ErrIntOverflowMapsproto2
7378 }
7379 if iNdEx >= l {
7380 return io.ErrUnexpectedEOF
7381 }
7382 b := dAtA[iNdEx]
7383 iNdEx++
7384 mapkeytemp |= int(b&0x7F) << shift
7385 if b < 0x80 {
7386 break
7387 }
7388 }
7389 mapkey = bool(mapkeytemp != 0)
7390 } else if fieldNum == 2 {
7391 var mapvaluetemp int
7392 for shift := uint(0); ; shift += 7 {
7393 if shift >= 64 {
7394 return ErrIntOverflowMapsproto2
7395 }
7396 if iNdEx >= l {
7397 return io.ErrUnexpectedEOF
7398 }
7399 b := dAtA[iNdEx]
7400 iNdEx++
7401 mapvaluetemp |= int(b&0x7F) << shift
7402 if b < 0x80 {
7403 break
7404 }
7405 }
7406 mapvalue = bool(mapvaluetemp != 0)
7407 } else {
7408 iNdEx = entryPreIndex
7409 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7410 if err != nil {
7411 return err
7412 }
7413 if (skippy < 0) || (iNdEx+skippy) < 0 {
7414 return ErrInvalidLengthMapsproto2
7415 }
7416 if (iNdEx + skippy) > postIndex {
7417 return io.ErrUnexpectedEOF
7418 }
7419 iNdEx += skippy
7420 }
7421 }
7422 m.BoolMap[mapkey] = mapvalue
7423 iNdEx = postIndex
7424 case 14:
7425 if wireType != 2 {
7426 return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
7427 }
7428 var msglen int
7429 for shift := uint(0); ; shift += 7 {
7430 if shift >= 64 {
7431 return ErrIntOverflowMapsproto2
7432 }
7433 if iNdEx >= l {
7434 return io.ErrUnexpectedEOF
7435 }
7436 b := dAtA[iNdEx]
7437 iNdEx++
7438 msglen |= int(b&0x7F) << shift
7439 if b < 0x80 {
7440 break
7441 }
7442 }
7443 if msglen < 0 {
7444 return ErrInvalidLengthMapsproto2
7445 }
7446 postIndex := iNdEx + msglen
7447 if postIndex < 0 {
7448 return ErrInvalidLengthMapsproto2
7449 }
7450 if postIndex > l {
7451 return io.ErrUnexpectedEOF
7452 }
7453 if m.StringMap == nil {
7454 m.StringMap = make(map[string]string)
7455 }
7456 var mapkey string
7457 var mapvalue string
7458 for iNdEx < postIndex {
7459 entryPreIndex := iNdEx
7460 var wire uint64
7461 for shift := uint(0); ; shift += 7 {
7462 if shift >= 64 {
7463 return ErrIntOverflowMapsproto2
7464 }
7465 if iNdEx >= l {
7466 return io.ErrUnexpectedEOF
7467 }
7468 b := dAtA[iNdEx]
7469 iNdEx++
7470 wire |= uint64(b&0x7F) << shift
7471 if b < 0x80 {
7472 break
7473 }
7474 }
7475 fieldNum := int32(wire >> 3)
7476 if fieldNum == 1 {
7477 var stringLenmapkey uint64
7478 for shift := uint(0); ; shift += 7 {
7479 if shift >= 64 {
7480 return ErrIntOverflowMapsproto2
7481 }
7482 if iNdEx >= l {
7483 return io.ErrUnexpectedEOF
7484 }
7485 b := dAtA[iNdEx]
7486 iNdEx++
7487 stringLenmapkey |= uint64(b&0x7F) << shift
7488 if b < 0x80 {
7489 break
7490 }
7491 }
7492 intStringLenmapkey := int(stringLenmapkey)
7493 if intStringLenmapkey < 0 {
7494 return ErrInvalidLengthMapsproto2
7495 }
7496 postStringIndexmapkey := iNdEx + intStringLenmapkey
7497 if postStringIndexmapkey < 0 {
7498 return ErrInvalidLengthMapsproto2
7499 }
7500 if postStringIndexmapkey > l {
7501 return io.ErrUnexpectedEOF
7502 }
7503 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7504 iNdEx = postStringIndexmapkey
7505 } else if fieldNum == 2 {
7506 var stringLenmapvalue uint64
7507 for shift := uint(0); ; shift += 7 {
7508 if shift >= 64 {
7509 return ErrIntOverflowMapsproto2
7510 }
7511 if iNdEx >= l {
7512 return io.ErrUnexpectedEOF
7513 }
7514 b := dAtA[iNdEx]
7515 iNdEx++
7516 stringLenmapvalue |= uint64(b&0x7F) << shift
7517 if b < 0x80 {
7518 break
7519 }
7520 }
7521 intStringLenmapvalue := int(stringLenmapvalue)
7522 if intStringLenmapvalue < 0 {
7523 return ErrInvalidLengthMapsproto2
7524 }
7525 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
7526 if postStringIndexmapvalue < 0 {
7527 return ErrInvalidLengthMapsproto2
7528 }
7529 if postStringIndexmapvalue > l {
7530 return io.ErrUnexpectedEOF
7531 }
7532 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
7533 iNdEx = postStringIndexmapvalue
7534 } else {
7535 iNdEx = entryPreIndex
7536 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7537 if err != nil {
7538 return err
7539 }
7540 if (skippy < 0) || (iNdEx+skippy) < 0 {
7541 return ErrInvalidLengthMapsproto2
7542 }
7543 if (iNdEx + skippy) > postIndex {
7544 return io.ErrUnexpectedEOF
7545 }
7546 iNdEx += skippy
7547 }
7548 }
7549 m.StringMap[mapkey] = mapvalue
7550 iNdEx = postIndex
7551 case 15:
7552 if wireType != 2 {
7553 return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
7554 }
7555 var msglen int
7556 for shift := uint(0); ; shift += 7 {
7557 if shift >= 64 {
7558 return ErrIntOverflowMapsproto2
7559 }
7560 if iNdEx >= l {
7561 return io.ErrUnexpectedEOF
7562 }
7563 b := dAtA[iNdEx]
7564 iNdEx++
7565 msglen |= int(b&0x7F) << shift
7566 if b < 0x80 {
7567 break
7568 }
7569 }
7570 if msglen < 0 {
7571 return ErrInvalidLengthMapsproto2
7572 }
7573 postIndex := iNdEx + msglen
7574 if postIndex < 0 {
7575 return ErrInvalidLengthMapsproto2
7576 }
7577 if postIndex > l {
7578 return io.ErrUnexpectedEOF
7579 }
7580 if m.StringToBytesMap == nil {
7581 m.StringToBytesMap = make(map[string][]byte)
7582 }
7583 var mapkey string
7584 mapvalue := []byte{}
7585 for iNdEx < postIndex {
7586 entryPreIndex := iNdEx
7587 var wire uint64
7588 for shift := uint(0); ; shift += 7 {
7589 if shift >= 64 {
7590 return ErrIntOverflowMapsproto2
7591 }
7592 if iNdEx >= l {
7593 return io.ErrUnexpectedEOF
7594 }
7595 b := dAtA[iNdEx]
7596 iNdEx++
7597 wire |= uint64(b&0x7F) << shift
7598 if b < 0x80 {
7599 break
7600 }
7601 }
7602 fieldNum := int32(wire >> 3)
7603 if fieldNum == 1 {
7604 var stringLenmapkey uint64
7605 for shift := uint(0); ; shift += 7 {
7606 if shift >= 64 {
7607 return ErrIntOverflowMapsproto2
7608 }
7609 if iNdEx >= l {
7610 return io.ErrUnexpectedEOF
7611 }
7612 b := dAtA[iNdEx]
7613 iNdEx++
7614 stringLenmapkey |= uint64(b&0x7F) << shift
7615 if b < 0x80 {
7616 break
7617 }
7618 }
7619 intStringLenmapkey := int(stringLenmapkey)
7620 if intStringLenmapkey < 0 {
7621 return ErrInvalidLengthMapsproto2
7622 }
7623 postStringIndexmapkey := iNdEx + intStringLenmapkey
7624 if postStringIndexmapkey < 0 {
7625 return ErrInvalidLengthMapsproto2
7626 }
7627 if postStringIndexmapkey > l {
7628 return io.ErrUnexpectedEOF
7629 }
7630 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7631 iNdEx = postStringIndexmapkey
7632 } else if fieldNum == 2 {
7633 var mapbyteLen uint64
7634 for shift := uint(0); ; shift += 7 {
7635 if shift >= 64 {
7636 return ErrIntOverflowMapsproto2
7637 }
7638 if iNdEx >= l {
7639 return io.ErrUnexpectedEOF
7640 }
7641 b := dAtA[iNdEx]
7642 iNdEx++
7643 mapbyteLen |= uint64(b&0x7F) << shift
7644 if b < 0x80 {
7645 break
7646 }
7647 }
7648 intMapbyteLen := int(mapbyteLen)
7649 if intMapbyteLen < 0 {
7650 return ErrInvalidLengthMapsproto2
7651 }
7652 postbytesIndex := iNdEx + intMapbyteLen
7653 if postbytesIndex < 0 {
7654 return ErrInvalidLengthMapsproto2
7655 }
7656 if postbytesIndex > l {
7657 return io.ErrUnexpectedEOF
7658 }
7659 mapvalue = make([]byte, mapbyteLen)
7660 copy(mapvalue, dAtA[iNdEx:postbytesIndex])
7661 iNdEx = postbytesIndex
7662 } else {
7663 iNdEx = entryPreIndex
7664 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7665 if err != nil {
7666 return err
7667 }
7668 if (skippy < 0) || (iNdEx+skippy) < 0 {
7669 return ErrInvalidLengthMapsproto2
7670 }
7671 if (iNdEx + skippy) > postIndex {
7672 return io.ErrUnexpectedEOF
7673 }
7674 iNdEx += skippy
7675 }
7676 }
7677 m.StringToBytesMap[mapkey] = mapvalue
7678 iNdEx = postIndex
7679 case 16:
7680 if wireType != 2 {
7681 return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
7682 }
7683 var msglen int
7684 for shift := uint(0); ; shift += 7 {
7685 if shift >= 64 {
7686 return ErrIntOverflowMapsproto2
7687 }
7688 if iNdEx >= l {
7689 return io.ErrUnexpectedEOF
7690 }
7691 b := dAtA[iNdEx]
7692 iNdEx++
7693 msglen |= int(b&0x7F) << shift
7694 if b < 0x80 {
7695 break
7696 }
7697 }
7698 if msglen < 0 {
7699 return ErrInvalidLengthMapsproto2
7700 }
7701 postIndex := iNdEx + msglen
7702 if postIndex < 0 {
7703 return ErrInvalidLengthMapsproto2
7704 }
7705 if postIndex > l {
7706 return io.ErrUnexpectedEOF
7707 }
7708 if m.StringToEnumMap == nil {
7709 m.StringToEnumMap = make(map[string]MapEnum)
7710 }
7711 var mapkey string
7712 var mapvalue MapEnum
7713 for iNdEx < postIndex {
7714 entryPreIndex := iNdEx
7715 var wire uint64
7716 for shift := uint(0); ; shift += 7 {
7717 if shift >= 64 {
7718 return ErrIntOverflowMapsproto2
7719 }
7720 if iNdEx >= l {
7721 return io.ErrUnexpectedEOF
7722 }
7723 b := dAtA[iNdEx]
7724 iNdEx++
7725 wire |= uint64(b&0x7F) << shift
7726 if b < 0x80 {
7727 break
7728 }
7729 }
7730 fieldNum := int32(wire >> 3)
7731 if fieldNum == 1 {
7732 var stringLenmapkey uint64
7733 for shift := uint(0); ; shift += 7 {
7734 if shift >= 64 {
7735 return ErrIntOverflowMapsproto2
7736 }
7737 if iNdEx >= l {
7738 return io.ErrUnexpectedEOF
7739 }
7740 b := dAtA[iNdEx]
7741 iNdEx++
7742 stringLenmapkey |= uint64(b&0x7F) << shift
7743 if b < 0x80 {
7744 break
7745 }
7746 }
7747 intStringLenmapkey := int(stringLenmapkey)
7748 if intStringLenmapkey < 0 {
7749 return ErrInvalidLengthMapsproto2
7750 }
7751 postStringIndexmapkey := iNdEx + intStringLenmapkey
7752 if postStringIndexmapkey < 0 {
7753 return ErrInvalidLengthMapsproto2
7754 }
7755 if postStringIndexmapkey > l {
7756 return io.ErrUnexpectedEOF
7757 }
7758 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7759 iNdEx = postStringIndexmapkey
7760 } else if fieldNum == 2 {
7761 for shift := uint(0); ; shift += 7 {
7762 if shift >= 64 {
7763 return ErrIntOverflowMapsproto2
7764 }
7765 if iNdEx >= l {
7766 return io.ErrUnexpectedEOF
7767 }
7768 b := dAtA[iNdEx]
7769 iNdEx++
7770 mapvalue |= MapEnum(b&0x7F) << shift
7771 if b < 0x80 {
7772 break
7773 }
7774 }
7775 } else {
7776 iNdEx = entryPreIndex
7777 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7778 if err != nil {
7779 return err
7780 }
7781 if (skippy < 0) || (iNdEx+skippy) < 0 {
7782 return ErrInvalidLengthMapsproto2
7783 }
7784 if (iNdEx + skippy) > postIndex {
7785 return io.ErrUnexpectedEOF
7786 }
7787 iNdEx += skippy
7788 }
7789 }
7790 m.StringToEnumMap[mapkey] = mapvalue
7791 iNdEx = postIndex
7792 case 17:
7793 if wireType != 2 {
7794 return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
7795 }
7796 var msglen int
7797 for shift := uint(0); ; shift += 7 {
7798 if shift >= 64 {
7799 return ErrIntOverflowMapsproto2
7800 }
7801 if iNdEx >= l {
7802 return io.ErrUnexpectedEOF
7803 }
7804 b := dAtA[iNdEx]
7805 iNdEx++
7806 msglen |= int(b&0x7F) << shift
7807 if b < 0x80 {
7808 break
7809 }
7810 }
7811 if msglen < 0 {
7812 return ErrInvalidLengthMapsproto2
7813 }
7814 postIndex := iNdEx + msglen
7815 if postIndex < 0 {
7816 return ErrInvalidLengthMapsproto2
7817 }
7818 if postIndex > l {
7819 return io.ErrUnexpectedEOF
7820 }
7821 if m.StringToMsgMap == nil {
7822 m.StringToMsgMap = make(map[string]*FloatingPoint)
7823 }
7824 var mapkey string
7825 var mapvalue *FloatingPoint
7826 for iNdEx < postIndex {
7827 entryPreIndex := iNdEx
7828 var wire uint64
7829 for shift := uint(0); ; shift += 7 {
7830 if shift >= 64 {
7831 return ErrIntOverflowMapsproto2
7832 }
7833 if iNdEx >= l {
7834 return io.ErrUnexpectedEOF
7835 }
7836 b := dAtA[iNdEx]
7837 iNdEx++
7838 wire |= uint64(b&0x7F) << shift
7839 if b < 0x80 {
7840 break
7841 }
7842 }
7843 fieldNum := int32(wire >> 3)
7844 if fieldNum == 1 {
7845 var stringLenmapkey uint64
7846 for shift := uint(0); ; shift += 7 {
7847 if shift >= 64 {
7848 return ErrIntOverflowMapsproto2
7849 }
7850 if iNdEx >= l {
7851 return io.ErrUnexpectedEOF
7852 }
7853 b := dAtA[iNdEx]
7854 iNdEx++
7855 stringLenmapkey |= uint64(b&0x7F) << shift
7856 if b < 0x80 {
7857 break
7858 }
7859 }
7860 intStringLenmapkey := int(stringLenmapkey)
7861 if intStringLenmapkey < 0 {
7862 return ErrInvalidLengthMapsproto2
7863 }
7864 postStringIndexmapkey := iNdEx + intStringLenmapkey
7865 if postStringIndexmapkey < 0 {
7866 return ErrInvalidLengthMapsproto2
7867 }
7868 if postStringIndexmapkey > l {
7869 return io.ErrUnexpectedEOF
7870 }
7871 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
7872 iNdEx = postStringIndexmapkey
7873 } else if fieldNum == 2 {
7874 var mapmsglen int
7875 for shift := uint(0); ; shift += 7 {
7876 if shift >= 64 {
7877 return ErrIntOverflowMapsproto2
7878 }
7879 if iNdEx >= l {
7880 return io.ErrUnexpectedEOF
7881 }
7882 b := dAtA[iNdEx]
7883 iNdEx++
7884 mapmsglen |= int(b&0x7F) << shift
7885 if b < 0x80 {
7886 break
7887 }
7888 }
7889 if mapmsglen < 0 {
7890 return ErrInvalidLengthMapsproto2
7891 }
7892 postmsgIndex := iNdEx + mapmsglen
7893 if postmsgIndex < 0 {
7894 return ErrInvalidLengthMapsproto2
7895 }
7896 if postmsgIndex > l {
7897 return io.ErrUnexpectedEOF
7898 }
7899 mapvalue = &FloatingPoint{}
7900 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
7901 return err
7902 }
7903 iNdEx = postmsgIndex
7904 } else {
7905 iNdEx = entryPreIndex
7906 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7907 if err != nil {
7908 return err
7909 }
7910 if (skippy < 0) || (iNdEx+skippy) < 0 {
7911 return ErrInvalidLengthMapsproto2
7912 }
7913 if (iNdEx + skippy) > postIndex {
7914 return io.ErrUnexpectedEOF
7915 }
7916 iNdEx += skippy
7917 }
7918 }
7919 m.StringToMsgMap[mapkey] = mapvalue
7920 iNdEx = postIndex
7921 default:
7922 iNdEx = preIndex
7923 skippy, err := skipMapsproto2(dAtA[iNdEx:])
7924 if err != nil {
7925 return err
7926 }
7927 if (skippy < 0) || (iNdEx+skippy) < 0 {
7928 return ErrInvalidLengthMapsproto2
7929 }
7930 if (iNdEx + skippy) > l {
7931 return io.ErrUnexpectedEOF
7932 }
7933 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
7934 iNdEx += skippy
7935 }
7936 }
7937
7938 if iNdEx > l {
7939 return io.ErrUnexpectedEOF
7940 }
7941 return nil
7942 }
7943 func skipMapsproto2(dAtA []byte) (n int, err error) {
7944 l := len(dAtA)
7945 iNdEx := 0
7946 depth := 0
7947 for iNdEx < l {
7948 var wire uint64
7949 for shift := uint(0); ; shift += 7 {
7950 if shift >= 64 {
7951 return 0, ErrIntOverflowMapsproto2
7952 }
7953 if iNdEx >= l {
7954 return 0, io.ErrUnexpectedEOF
7955 }
7956 b := dAtA[iNdEx]
7957 iNdEx++
7958 wire |= (uint64(b) & 0x7F) << shift
7959 if b < 0x80 {
7960 break
7961 }
7962 }
7963 wireType := int(wire & 0x7)
7964 switch wireType {
7965 case 0:
7966 for shift := uint(0); ; shift += 7 {
7967 if shift >= 64 {
7968 return 0, ErrIntOverflowMapsproto2
7969 }
7970 if iNdEx >= l {
7971 return 0, io.ErrUnexpectedEOF
7972 }
7973 iNdEx++
7974 if dAtA[iNdEx-1] < 0x80 {
7975 break
7976 }
7977 }
7978 case 1:
7979 iNdEx += 8
7980 case 2:
7981 var length int
7982 for shift := uint(0); ; shift += 7 {
7983 if shift >= 64 {
7984 return 0, ErrIntOverflowMapsproto2
7985 }
7986 if iNdEx >= l {
7987 return 0, io.ErrUnexpectedEOF
7988 }
7989 b := dAtA[iNdEx]
7990 iNdEx++
7991 length |= (int(b) & 0x7F) << shift
7992 if b < 0x80 {
7993 break
7994 }
7995 }
7996 if length < 0 {
7997 return 0, ErrInvalidLengthMapsproto2
7998 }
7999 iNdEx += length
8000 case 3:
8001 depth++
8002 case 4:
8003 if depth == 0 {
8004 return 0, ErrUnexpectedEndOfGroupMapsproto2
8005 }
8006 depth--
8007 case 5:
8008 iNdEx += 4
8009 default:
8010 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
8011 }
8012 if iNdEx < 0 {
8013 return 0, ErrInvalidLengthMapsproto2
8014 }
8015 if depth == 0 {
8016 return iNdEx, nil
8017 }
8018 }
8019 return 0, io.ErrUnexpectedEOF
8020 }
8021
8022 var (
8023 ErrInvalidLengthMapsproto2 = fmt.Errorf("proto: negative length found during unmarshaling")
8024 ErrIntOverflowMapsproto2 = fmt.Errorf("proto: integer overflow")
8025 ErrUnexpectedEndOfGroupMapsproto2 = fmt.Errorf("proto: unexpected end of group")
8026 )
8027
View as plain text