Source file src/github.com/gogo/protobuf/test/mapdefaults/combos/both/map.pb.go

Documentation: github.com/gogo/protobuf/test/mapdefaults/combos/both

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: combos/both/map.proto
     3  
     4  package mapdefaults
     5  
     6  import (
     7  	bytes "bytes"
     8  	compress_gzip "compress/gzip"
     9  	fmt "fmt"
    10  	_ "github.com/gogo/protobuf/gogoproto"
    11  	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
    12  	proto "github.com/gogo/protobuf/proto"
    13  	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
    14  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    15  	io "io"
    16  	io_ioutil "io/ioutil"
    17  	math "math"
    18  	math_bits "math/bits"
    19  	reflect "reflect"
    20  	strings "strings"
    21  )
    22  
    23  // Reference imports to suppress errors if they are not otherwise used.
    24  var _ = proto.Marshal
    25  var _ = fmt.Errorf
    26  var _ = math.Inf
    27  
    28  // This is a compile-time assertion to ensure that this generated file
    29  // is compatible with the proto package it is being compiled against.
    30  // A compilation error at this line likely means your copy of the
    31  // proto package needs to be updated.
    32  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    33  
    34  type MapTest struct {
    35  	StrStr               map[string]string `protobuf:"bytes,1,rep,name=str_str,json=strStr,proto3" json:"str_str,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
    36  	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
    37  	XXX_unrecognized     []byte            `json:"-"`
    38  	XXX_sizecache        int32             `json:"-"`
    39  }
    40  
    41  func (m *MapTest) Reset()      { *m = MapTest{} }
    42  func (*MapTest) ProtoMessage() {}
    43  func (*MapTest) Descriptor() ([]byte, []int) {
    44  	return fileDescriptor_b8f2a09ffeba7c12, []int{0}
    45  }
    46  func (m *MapTest) XXX_Unmarshal(b []byte) error {
    47  	return m.Unmarshal(b)
    48  }
    49  func (m *MapTest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    50  	if deterministic {
    51  		return xxx_messageInfo_MapTest.Marshal(b, m, deterministic)
    52  	} else {
    53  		b = b[:cap(b)]
    54  		n, err := m.MarshalToSizedBuffer(b)
    55  		if err != nil {
    56  			return nil, err
    57  		}
    58  		return b[:n], nil
    59  	}
    60  }
    61  func (m *MapTest) XXX_Merge(src proto.Message) {
    62  	xxx_messageInfo_MapTest.Merge(m, src)
    63  }
    64  func (m *MapTest) XXX_Size() int {
    65  	return m.Size()
    66  }
    67  func (m *MapTest) XXX_DiscardUnknown() {
    68  	xxx_messageInfo_MapTest.DiscardUnknown(m)
    69  }
    70  
    71  var xxx_messageInfo_MapTest proto.InternalMessageInfo
    72  
    73  type FakeMap struct {
    74  	Entries              []*FakeMapEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
    75  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
    76  	XXX_unrecognized     []byte          `json:"-"`
    77  	XXX_sizecache        int32           `json:"-"`
    78  }
    79  
    80  func (m *FakeMap) Reset()      { *m = FakeMap{} }
    81  func (*FakeMap) ProtoMessage() {}
    82  func (*FakeMap) Descriptor() ([]byte, []int) {
    83  	return fileDescriptor_b8f2a09ffeba7c12, []int{1}
    84  }
    85  func (m *FakeMap) XXX_Unmarshal(b []byte) error {
    86  	return m.Unmarshal(b)
    87  }
    88  func (m *FakeMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    89  	if deterministic {
    90  		return xxx_messageInfo_FakeMap.Marshal(b, m, deterministic)
    91  	} else {
    92  		b = b[:cap(b)]
    93  		n, err := m.MarshalToSizedBuffer(b)
    94  		if err != nil {
    95  			return nil, err
    96  		}
    97  		return b[:n], nil
    98  	}
    99  }
   100  func (m *FakeMap) XXX_Merge(src proto.Message) {
   101  	xxx_messageInfo_FakeMap.Merge(m, src)
   102  }
   103  func (m *FakeMap) XXX_Size() int {
   104  	return m.Size()
   105  }
   106  func (m *FakeMap) XXX_DiscardUnknown() {
   107  	xxx_messageInfo_FakeMap.DiscardUnknown(m)
   108  }
   109  
   110  var xxx_messageInfo_FakeMap proto.InternalMessageInfo
   111  
   112  type FakeMapEntry struct {
   113  	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
   114  	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
   115  	Other                string   `protobuf:"bytes,3,opt,name=other,proto3" json:"other,omitempty"`
   116  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   117  	XXX_unrecognized     []byte   `json:"-"`
   118  	XXX_sizecache        int32    `json:"-"`
   119  }
   120  
   121  func (m *FakeMapEntry) Reset()      { *m = FakeMapEntry{} }
   122  func (*FakeMapEntry) ProtoMessage() {}
   123  func (*FakeMapEntry) Descriptor() ([]byte, []int) {
   124  	return fileDescriptor_b8f2a09ffeba7c12, []int{2}
   125  }
   126  func (m *FakeMapEntry) XXX_Unmarshal(b []byte) error {
   127  	return m.Unmarshal(b)
   128  }
   129  func (m *FakeMapEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   130  	if deterministic {
   131  		return xxx_messageInfo_FakeMapEntry.Marshal(b, m, deterministic)
   132  	} else {
   133  		b = b[:cap(b)]
   134  		n, err := m.MarshalToSizedBuffer(b)
   135  		if err != nil {
   136  			return nil, err
   137  		}
   138  		return b[:n], nil
   139  	}
   140  }
   141  func (m *FakeMapEntry) XXX_Merge(src proto.Message) {
   142  	xxx_messageInfo_FakeMapEntry.Merge(m, src)
   143  }
   144  func (m *FakeMapEntry) XXX_Size() int {
   145  	return m.Size()
   146  }
   147  func (m *FakeMapEntry) XXX_DiscardUnknown() {
   148  	xxx_messageInfo_FakeMapEntry.DiscardUnknown(m)
   149  }
   150  
   151  var xxx_messageInfo_FakeMapEntry proto.InternalMessageInfo
   152  
   153  func init() {
   154  	proto.RegisterType((*MapTest)(nil), "mapdefaults.MapTest")
   155  	proto.RegisterMapType((map[string]string)(nil), "mapdefaults.MapTest.StrStrEntry")
   156  	proto.RegisterType((*FakeMap)(nil), "mapdefaults.FakeMap")
   157  	proto.RegisterType((*FakeMapEntry)(nil), "mapdefaults.FakeMapEntry")
   158  }
   159  
   160  func init() { proto.RegisterFile("combos/both/map.proto", fileDescriptor_b8f2a09ffeba7c12) }
   161  
   162  var fileDescriptor_b8f2a09ffeba7c12 = []byte{
   163  	// 310 bytes of a gzipped FileDescriptorProto
   164  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0xbf, 0x4f, 0xc2, 0x40,
   165  	0x14, 0xc7, 0xfb, 0x20, 0xd2, 0x78, 0x38, 0x98, 0x46, 0x93, 0xca, 0xf0, 0x42, 0x98, 0x58, 0x6c,
   166  	0x13, 0x59, 0xc4, 0xc1, 0xc1, 0xa8, 0x93, 0x2c, 0xe0, 0x6e, 0xae, 0x78, 0xfc, 0x08, 0x94, 0x6b,
   167  	0xee, 0x5e, 0x4d, 0x98, 0xe4, 0xcf, 0x71, 0x74, 0xf4, 0x4f, 0x60, 0x64, 0x74, 0xa4, 0xe7, 0xe2,
   168  	0xc8, 0xc8, 0x68, 0xb8, 0x62, 0x52, 0x37, 0xb7, 0xf7, 0xf9, 0xde, 0xe7, 0xee, 0x7d, 0x73, 0xec,
   169  	0xb4, 0x2f, 0xe3, 0x48, 0xea, 0x30, 0x92, 0x34, 0x0a, 0x63, 0x9e, 0x04, 0x89, 0x92, 0x24, 0xbd,
   170  	0x6a, 0xcc, 0x93, 0x67, 0x31, 0xe0, 0xe9, 0x94, 0x74, 0xed, 0x7c, 0x38, 0xa6, 0x51, 0x1a, 0x05,
   171  	0x7d, 0x19, 0x87, 0x43, 0x39, 0x94, 0xa1, 0x75, 0xa2, 0x74, 0x60, 0xc9, 0x82, 0x9d, 0xf2, 0xbb,
   172  	0x8d, 0x57, 0xe6, 0x76, 0x78, 0xf2, 0x28, 0x34, 0x79, 0x6d, 0xe6, 0x6a, 0x52, 0x4f, 0x9a, 0x94,
   173  	0x0f, 0xf5, 0x72, 0xb3, 0x7a, 0x51, 0x0f, 0x0a, 0x0f, 0x07, 0x7b, 0x2d, 0xe8, 0x91, 0xea, 0x91,
   174  	0xba, 0x9b, 0x91, 0x9a, 0x77, 0x2b, 0xda, 0x42, 0xad, 0xcd, 0xaa, 0x85, 0xd8, 0x3b, 0x66, 0xe5,
   175  	0x89, 0x98, 0xfb, 0x50, 0x87, 0xe6, 0x61, 0x77, 0x37, 0x7a, 0x27, 0xec, 0xe0, 0x85, 0x4f, 0x53,
   176  	0xe1, 0x97, 0x6c, 0x96, 0xc3, 0x55, 0xe9, 0x12, 0x1a, 0xd7, 0xcc, 0xbd, 0xe7, 0x13, 0xd1, 0xe1,
   177  	0x89, 0xd7, 0x62, 0xae, 0x98, 0x91, 0x1a, 0x0b, 0xbd, 0x2f, 0x70, 0xf6, 0xa7, 0xc0, 0x5e, 0xcb,
   178  	0x37, 0xff, 0x9a, 0x8d, 0x07, 0x76, 0x54, 0x3c, 0xf8, 0xef, 0xee, 0x5d, 0x2a, 0x69, 0x24, 0x94,
   179  	0x5f, 0xce, 0x53, 0x0b, 0x37, 0xb7, 0xcb, 0x0c, 0x9d, 0x55, 0x86, 0xce, 0x67, 0x86, 0xce, 0x3a,
   180  	0x43, 0xd8, 0x64, 0x08, 0xdb, 0x0c, 0x61, 0x61, 0x10, 0xde, 0x0c, 0xc2, 0xbb, 0x41, 0xf8, 0x30,
   181  	0x08, 0x4b, 0x83, 0xb0, 0x32, 0x08, 0x6b, 0x83, 0xf0, 0x6d, 0xd0, 0xd9, 0x18, 0x84, 0xad, 0x41,
   182  	0x67, 0xf1, 0x85, 0x4e, 0x54, 0xb1, 0x7f, 0xdb, 0xfa, 0x09, 0x00, 0x00, 0xff, 0xff, 0x11, 0xc9,
   183  	0x76, 0xfa, 0xb0, 0x01, 0x00, 0x00,
   184  }
   185  
   186  func (this *MapTest) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
   187  	return MapDescription()
   188  }
   189  func (this *FakeMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
   190  	return MapDescription()
   191  }
   192  func (this *FakeMapEntry) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
   193  	return MapDescription()
   194  }
   195  func MapDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
   196  	d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
   197  	var gzipped = []byte{
   198  		// 4011 bytes of a gzipped FileDescriptorSet
   199  		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5b, 0x70, 0xe3, 0xe6,
   200  		0x75, 0x16, 0x78, 0x91, 0xc8, 0x43, 0x8a, 0x82, 0x20, 0xad, 0x96, 0x2b, 0xc7, 0x5c, 0x2d, 0x6d,
   201  		0xc7, 0xb2, 0x1d, 0x4b, 0x99, 0xbd, 0x79, 0x97, 0xdb, 0xd8, 0xa5, 0x24, 0xae, 0x22, 0x57, 0xb7,
   202  		0x80, 0x52, 0x7c, 0xc9, 0x74, 0x30, 0x10, 0xf8, 0x8b, 0xc4, 0x0a, 0x04, 0x10, 0x00, 0xdc, 0xb5,
   203  		0x76, 0x3a, 0xd3, 0xed, 0xb8, 0x97, 0xc9, 0xf4, 0x7e, 0x99, 0x69, 0xe2, 0x3a, 0x6e, 0x93, 0x4e,
   204  		0xe3, 0x34, 0xbd, 0x39, 0xbd, 0xa4, 0x49, 0xfa, 0xd2, 0x97, 0xb4, 0x7e, 0xea, 0x24, 0x6f, 0x7d,
   205  		0xe8, 0x83, 0x57, 0xf1, 0x4c, 0xd3, 0xd6, 0x6d, 0xdd, 0x76, 0x1f, 0x3c, 0xe3, 0x97, 0xce, 0x7f,
   206  		0x03, 0x01, 0x90, 0x5a, 0x40, 0x99, 0xb1, 0xfd, 0x24, 0xe1, 0xfc, 0xe7, 0xfb, 0x70, 0xfe, 0xf3,
   207  		0x9f, 0xff, 0x9c, 0xf3, 0xff, 0x20, 0xbc, 0x59, 0x83, 0xb9, 0xb6, 0x65, 0xb5, 0x0d, 0xb4, 0x68,
   208  		0x3b, 0x96, 0x67, 0xed, 0xf5, 0xf6, 0x17, 0x5b, 0xc8, 0xd5, 0x1c, 0xdd, 0xf6, 0x2c, 0x67, 0x81,
   209  		0xc8, 0xa4, 0x09, 0xaa, 0xb1, 0xc0, 0x35, 0xaa, 0x1b, 0x30, 0x79, 0x5d, 0x37, 0xd0, 0x8a, 0xaf,
   210  		0xd8, 0x44, 0x9e, 0x74, 0x05, 0x32, 0xfb, 0xba, 0x81, 0xca, 0xc2, 0x5c, 0x7a, 0xbe, 0x70, 0xfe,
   211  		0xe1, 0x85, 0x08, 0x68, 0x21, 0x8c, 0xd8, 0xc6, 0x62, 0x99, 0x20, 0xaa, 0x6f, 0x67, 0x60, 0x6a,
   212  		0xc8, 0xa8, 0x24, 0x41, 0xc6, 0x54, 0xbb, 0x98, 0x51, 0x98, 0xcf, 0xcb, 0xe4, 0x7f, 0xa9, 0x0c,
   213  		0x63, 0xb6, 0xaa, 0x1d, 0xa8, 0x6d, 0x54, 0x4e, 0x11, 0x31, 0x7f, 0x94, 0x2a, 0x00, 0x2d, 0x64,
   214  		0x23, 0xb3, 0x85, 0x4c, 0xed, 0xb0, 0x9c, 0x9e, 0x4b, 0xcf, 0xe7, 0xe5, 0x80, 0x44, 0x7a, 0x02,
   215  		0x26, 0xed, 0xde, 0x9e, 0xa1, 0x6b, 0x4a, 0x40, 0x0d, 0xe6, 0xd2, 0xf3, 0x59, 0x59, 0xa4, 0x03,
   216  		0x2b, 0x7d, 0xe5, 0x47, 0x61, 0xe2, 0x16, 0x52, 0x0f, 0x82, 0xaa, 0x05, 0xa2, 0x5a, 0xc2, 0xe2,
   217  		0x80, 0xe2, 0x32, 0x14, 0xbb, 0xc8, 0x75, 0xd5, 0x36, 0x52, 0xbc, 0x43, 0x1b, 0x95, 0x33, 0x64,
   218  		0xf6, 0x73, 0x03, 0xb3, 0x8f, 0xce, 0xbc, 0xc0, 0x50, 0x3b, 0x87, 0x36, 0x92, 0xea, 0x90, 0x47,
   219  		0x66, 0xaf, 0x4b, 0x19, 0xb2, 0xc7, 0xf8, 0xaf, 0x61, 0xf6, 0xba, 0x51, 0x96, 0x1c, 0x86, 0x31,
   220  		0x8a, 0x31, 0x17, 0x39, 0x37, 0x75, 0x0d, 0x95, 0x47, 0x09, 0xc1, 0xa3, 0x03, 0x04, 0x4d, 0x3a,
   221  		0x1e, 0xe5, 0xe0, 0x38, 0x69, 0x19, 0xf2, 0xe8, 0x25, 0x0f, 0x99, 0xae, 0x6e, 0x99, 0xe5, 0x31,
   222  		0x42, 0xf2, 0xc8, 0x90, 0x55, 0x44, 0x46, 0x2b, 0x4a, 0xd1, 0xc7, 0x49, 0x97, 0x61, 0xcc, 0xb2,
   223  		0x3d, 0xdd, 0x32, 0xdd, 0x72, 0x6e, 0x4e, 0x98, 0x2f, 0x9c, 0xff, 0xd8, 0xd0, 0x40, 0xd8, 0xa2,
   224  		0x3a, 0x32, 0x57, 0x96, 0xd6, 0x40, 0x74, 0xad, 0x9e, 0xa3, 0x21, 0x45, 0xb3, 0x5a, 0x48, 0xd1,
   225  		0xcd, 0x7d, 0xab, 0x9c, 0x27, 0x04, 0x67, 0x07, 0x27, 0x42, 0x14, 0x97, 0xad, 0x16, 0x5a, 0x33,
   226  		0xf7, 0x2d, 0xb9, 0xe4, 0x86, 0x9e, 0xa5, 0x19, 0x18, 0x75, 0x0f, 0x4d, 0x4f, 0x7d, 0xa9, 0x5c,
   227  		0x24, 0x11, 0xc2, 0x9e, 0xaa, 0xdf, 0x19, 0x85, 0x89, 0x24, 0x21, 0x76, 0x0d, 0xb2, 0xfb, 0x78,
   228  		0x96, 0xe5, 0xd4, 0x49, 0x7c, 0x40, 0x31, 0x61, 0x27, 0x8e, 0xfe, 0x98, 0x4e, 0xac, 0x43, 0xc1,
   229  		0x44, 0xae, 0x87, 0x5a, 0x34, 0x22, 0xd2, 0x09, 0x63, 0x0a, 0x28, 0x68, 0x30, 0xa4, 0x32, 0x3f,
   230  		0x56, 0x48, 0x3d, 0x0f, 0x13, 0xbe, 0x49, 0x8a, 0xa3, 0x9a, 0x6d, 0x1e, 0x9b, 0x8b, 0x71, 0x96,
   231  		0x2c, 0x34, 0x38, 0x4e, 0xc6, 0x30, 0xb9, 0x84, 0x42, 0xcf, 0xd2, 0x0a, 0x80, 0x65, 0x22, 0x6b,
   232  		0x5f, 0x69, 0x21, 0xcd, 0x28, 0xe7, 0x8e, 0xf1, 0xd2, 0x16, 0x56, 0x19, 0xf0, 0x92, 0x45, 0xa5,
   233  		0x9a, 0x21, 0x5d, 0xed, 0x87, 0xda, 0xd8, 0x31, 0x91, 0xb2, 0x41, 0x37, 0xd9, 0x40, 0xb4, 0xed,
   234  		0x42, 0xc9, 0x41, 0x38, 0xee, 0x51, 0x8b, 0xcd, 0x2c, 0x4f, 0x8c, 0x58, 0x88, 0x9d, 0x99, 0xcc,
   235  		0x60, 0x74, 0x62, 0xe3, 0x4e, 0xf0, 0x51, 0x7a, 0x08, 0x7c, 0x81, 0x42, 0xc2, 0x0a, 0x48, 0x16,
   236  		0x2a, 0x72, 0xe1, 0xa6, 0xda, 0x45, 0xb3, 0xb7, 0xa1, 0x14, 0x76, 0x8f, 0x34, 0x0d, 0x59, 0xd7,
   237  		0x53, 0x1d, 0x8f, 0x44, 0x61, 0x56, 0xa6, 0x0f, 0x92, 0x08, 0x69, 0x64, 0xb6, 0x48, 0x96, 0xcb,
   238  		0xca, 0xf8, 0x5f, 0xe9, 0x27, 0xfb, 0x13, 0x4e, 0x93, 0x09, 0x7f, 0x7c, 0x70, 0x45, 0x43, 0xcc,
   239  		0xd1, 0x79, 0xcf, 0x3e, 0x05, 0xe3, 0xa1, 0x09, 0x24, 0x7d, 0x75, 0xf5, 0x67, 0xe0, 0xd4, 0x50,
   240  		0x6a, 0xe9, 0x79, 0x98, 0xee, 0x99, 0xba, 0xe9, 0x21, 0xc7, 0x76, 0x10, 0x8e, 0x58, 0xfa, 0xaa,
   241  		0xf2, 0xbf, 0x8e, 0x1d, 0x13, 0x73, 0xbb, 0x41, 0x6d, 0xca, 0x22, 0x4f, 0xf5, 0x06, 0x85, 0x8f,
   242  		0xe7, 0x73, 0x3f, 0x1a, 0x13, 0xef, 0xdc, 0xb9, 0x73, 0x27, 0x55, 0xfd, 0xe2, 0x28, 0x4c, 0x0f,
   243  		0xdb, 0x33, 0x43, 0xb7, 0xef, 0x0c, 0x8c, 0x9a, 0xbd, 0xee, 0x1e, 0x72, 0x88, 0x93, 0xb2, 0x32,
   244  		0x7b, 0x92, 0xea, 0x90, 0x35, 0xd4, 0x3d, 0x64, 0x94, 0x33, 0x73, 0xc2, 0x7c, 0xe9, 0xfc, 0x13,
   245  		0x89, 0x76, 0xe5, 0xc2, 0x3a, 0x86, 0xc8, 0x14, 0x29, 0x3d, 0x0d, 0x19, 0x96, 0xa2, 0x31, 0xc3,
   246  		0xe3, 0xc9, 0x18, 0xf0, 0x5e, 0x92, 0x09, 0x4e, 0x7a, 0x00, 0xf2, 0xf8, 0x2f, 0x8d, 0x8d, 0x51,
   247  		0x62, 0x73, 0x0e, 0x0b, 0x70, 0x5c, 0x48, 0xb3, 0x90, 0x23, 0xdb, 0xa4, 0x85, 0x78, 0x69, 0xf3,
   248  		0x9f, 0x71, 0x60, 0xb5, 0xd0, 0xbe, 0xda, 0x33, 0x3c, 0xe5, 0xa6, 0x6a, 0xf4, 0x10, 0x09, 0xf8,
   249  		0xbc, 0x5c, 0x64, 0xc2, 0xcf, 0x62, 0x99, 0x74, 0x16, 0x0a, 0x74, 0x57, 0xe9, 0x66, 0x0b, 0xbd,
   250  		0x44, 0xb2, 0x67, 0x56, 0xa6, 0x1b, 0x6d, 0x0d, 0x4b, 0xf0, 0xeb, 0x6f, 0xb8, 0x96, 0xc9, 0x43,
   251  		0x93, 0xbc, 0x02, 0x0b, 0xc8, 0xeb, 0x9f, 0x8a, 0x26, 0xee, 0x07, 0x87, 0x4f, 0x2f, 0x1a, 0x53,
   252  		0xd5, 0x6f, 0xa5, 0x20, 0x43, 0xf2, 0xc5, 0x04, 0x14, 0x76, 0x5e, 0xd8, 0x6e, 0x28, 0x2b, 0x5b,
   253  		0xbb, 0x4b, 0xeb, 0x0d, 0x51, 0x90, 0x4a, 0x00, 0x44, 0x70, 0x7d, 0x7d, 0xab, 0xbe, 0x23, 0xa6,
   254  		0xfc, 0xe7, 0xb5, 0xcd, 0x9d, 0xcb, 0x17, 0xc5, 0xb4, 0x0f, 0xd8, 0xa5, 0x82, 0x4c, 0x50, 0xe1,
   255  		0xc2, 0x79, 0x31, 0x2b, 0x89, 0x50, 0xa4, 0x04, 0x6b, 0xcf, 0x37, 0x56, 0x2e, 0x5f, 0x14, 0x47,
   256  		0xc3, 0x92, 0x0b, 0xe7, 0xc5, 0x31, 0x69, 0x1c, 0xf2, 0x44, 0xb2, 0xb4, 0xb5, 0xb5, 0x2e, 0xe6,
   257  		0x7c, 0xce, 0xe6, 0x8e, 0xbc, 0xb6, 0xb9, 0x2a, 0xe6, 0x7d, 0xce, 0x55, 0x79, 0x6b, 0x77, 0x5b,
   258  		0x04, 0x9f, 0x61, 0xa3, 0xd1, 0x6c, 0xd6, 0x57, 0x1b, 0x62, 0xc1, 0xd7, 0x58, 0x7a, 0x61, 0xa7,
   259  		0xd1, 0x14, 0x8b, 0x21, 0xb3, 0x2e, 0x9c, 0x17, 0xc7, 0xfd, 0x57, 0x34, 0x36, 0x77, 0x37, 0xc4,
   260  		0x92, 0x34, 0x09, 0xe3, 0xf4, 0x15, 0xdc, 0x88, 0x89, 0x88, 0xe8, 0xf2, 0x45, 0x51, 0xec, 0x1b,
   261  		0x42, 0x59, 0x26, 0x43, 0x82, 0xcb, 0x17, 0x45, 0xa9, 0xba, 0x0c, 0x59, 0x12, 0x5d, 0x92, 0x04,
   262  		0xa5, 0xf5, 0xfa, 0x52, 0x63, 0x5d, 0xd9, 0xda, 0xde, 0x59, 0xdb, 0xda, 0xac, 0xaf, 0x8b, 0x42,
   263  		0x5f, 0x26, 0x37, 0x3e, 0xb3, 0xbb, 0x26, 0x37, 0x56, 0xc4, 0x54, 0x50, 0xb6, 0xdd, 0xa8, 0xef,
   264  		0x34, 0x56, 0xc4, 0x74, 0x55, 0x83, 0xe9, 0x61, 0x79, 0x72, 0xe8, 0xce, 0x08, 0x2c, 0x71, 0xea,
   265  		0x98, 0x25, 0x26, 0x5c, 0x03, 0x4b, 0xfc, 0xc3, 0x14, 0x4c, 0x0d, 0xa9, 0x15, 0x43, 0x5f, 0xf2,
   266  		0x0c, 0x64, 0x69, 0x88, 0xd2, 0xea, 0xf9, 0xd8, 0xd0, 0xa2, 0x43, 0x02, 0x76, 0xa0, 0x82, 0x12,
   267  		0x5c, 0xb0, 0x83, 0x48, 0x1f, 0xd3, 0x41, 0x60, 0x8a, 0x81, 0x9c, 0xfe, 0xd3, 0x03, 0x39, 0x9d,
   268  		0x96, 0xbd, 0xcb, 0x49, 0xca, 0x1e, 0x91, 0x9d, 0x2c, 0xb7, 0x67, 0x87, 0xe4, 0xf6, 0x6b, 0x30,
   269  		0x39, 0x40, 0x94, 0x38, 0xc7, 0xbe, 0x2c, 0x40, 0xf9, 0x38, 0xe7, 0xc4, 0x64, 0xba, 0x54, 0x28,
   270  		0xd3, 0x5d, 0x8b, 0x7a, 0xf0, 0xdc, 0xf1, 0x8b, 0x30, 0xb0, 0xd6, 0xaf, 0x0b, 0x30, 0x33, 0xbc,
   271  		0x53, 0x1c, 0x6a, 0xc3, 0xd3, 0x30, 0xda, 0x45, 0x5e, 0xc7, 0xe2, 0xdd, 0xd2, 0xc7, 0x87, 0xd4,
   272  		0x60, 0x3c, 0x1c, 0x5d, 0x6c, 0x86, 0x0a, 0x16, 0xf1, 0xf4, 0x71, 0xed, 0x1e, 0xb5, 0x66, 0xc0,
   273  		0xd2, 0x2f, 0xa4, 0xe0, 0xd4, 0x50, 0xf2, 0xa1, 0x86, 0x3e, 0x08, 0xa0, 0x9b, 0x76, 0xcf, 0xa3,
   274  		0x1d, 0x11, 0x4d, 0xb0, 0x79, 0x22, 0x21, 0xc9, 0x0b, 0x27, 0xcf, 0x9e, 0xe7, 0x8f, 0xa7, 0xc9,
   275  		0x38, 0x50, 0x11, 0x51, 0xb8, 0xd2, 0x37, 0x34, 0x43, 0x0c, 0xad, 0x1c, 0x33, 0xd3, 0x81, 0xc0,
   276  		0xfc, 0x24, 0x88, 0x9a, 0xa1, 0x23, 0xd3, 0x53, 0x5c, 0xcf, 0x41, 0x6a, 0x57, 0x37, 0xdb, 0xa4,
   277  		0x82, 0xe4, 0x6a, 0xd9, 0x7d, 0xd5, 0x70, 0x91, 0x3c, 0x41, 0x87, 0x9b, 0x7c, 0x14, 0x23, 0x48,
   278  		0x00, 0x39, 0x01, 0xc4, 0x68, 0x08, 0x41, 0x87, 0x7d, 0x44, 0xf5, 0x57, 0xf2, 0x50, 0x08, 0xf4,
   279  		0xd5, 0xd2, 0x39, 0x28, 0xde, 0x50, 0x6f, 0xaa, 0x0a, 0x3f, 0x2b, 0x51, 0x4f, 0x14, 0xb0, 0x6c,
   280  		0x9b, 0x9d, 0x97, 0x3e, 0x09, 0xd3, 0x44, 0xc5, 0xea, 0x79, 0xc8, 0x51, 0x34, 0x43, 0x75, 0x5d,
   281  		0xe2, 0xb4, 0x1c, 0x51, 0x95, 0xf0, 0xd8, 0x16, 0x1e, 0x5a, 0xe6, 0x23, 0xd2, 0x25, 0x98, 0x22,
   282  		0x88, 0x6e, 0xcf, 0xf0, 0x74, 0xdb, 0x40, 0x0a, 0x3e, 0xbd, 0xb9, 0xa4, 0x92, 0xf8, 0x96, 0x4d,
   283  		0x62, 0x8d, 0x0d, 0xa6, 0x80, 0x2d, 0x72, 0xa5, 0x15, 0x78, 0x90, 0xc0, 0xda, 0xc8, 0x44, 0x8e,
   284  		0xea, 0x21, 0x05, 0x7d, 0xbe, 0xa7, 0x1a, 0xae, 0xa2, 0x9a, 0x2d, 0xa5, 0xa3, 0xba, 0x9d, 0xf2,
   285  		0x34, 0x26, 0x58, 0x4a, 0x95, 0x05, 0xf9, 0x0c, 0x56, 0x5c, 0x65, 0x7a, 0x0d, 0xa2, 0x56, 0x37,
   286  		0x5b, 0x9f, 0x56, 0xdd, 0x8e, 0x54, 0x83, 0x19, 0xc2, 0xe2, 0x7a, 0x8e, 0x6e, 0xb6, 0x15, 0xad,
   287  		0x83, 0xb4, 0x03, 0xa5, 0xe7, 0xed, 0x5f, 0x29, 0x3f, 0x10, 0x7c, 0x3f, 0xb1, 0xb0, 0x49, 0x74,
   288  		0x96, 0xb1, 0xca, 0xae, 0xb7, 0x7f, 0x45, 0x6a, 0x42, 0x11, 0x2f, 0x46, 0x57, 0xbf, 0x8d, 0x94,
   289  		0x7d, 0xcb, 0x21, 0xa5, 0xb1, 0x34, 0x24, 0x35, 0x05, 0x3c, 0xb8, 0xb0, 0xc5, 0x00, 0x1b, 0x56,
   290  		0x0b, 0xd5, 0xb2, 0xcd, 0xed, 0x46, 0x63, 0x45, 0x2e, 0x70, 0x96, 0xeb, 0x96, 0x83, 0x03, 0xaa,
   291  		0x6d, 0xf9, 0x0e, 0x2e, 0xd0, 0x80, 0x6a, 0x5b, 0xdc, 0xbd, 0x97, 0x60, 0x4a, 0xd3, 0xe8, 0x9c,
   292  		0x75, 0x4d, 0x61, 0x67, 0x2c, 0xb7, 0x2c, 0x86, 0x9c, 0xa5, 0x69, 0xab, 0x54, 0x81, 0xc5, 0xb8,
   293  		0x2b, 0x5d, 0x85, 0x53, 0x7d, 0x67, 0x05, 0x81, 0x93, 0x03, 0xb3, 0x8c, 0x42, 0x2f, 0xc1, 0x94,
   294  		0x7d, 0x38, 0x08, 0x94, 0x42, 0x6f, 0xb4, 0x0f, 0xa3, 0xb0, 0xa7, 0x60, 0xda, 0xee, 0xd8, 0x83,
   295  		0xb8, 0xc7, 0x83, 0x38, 0xc9, 0xee, 0xd8, 0x51, 0xe0, 0x23, 0xe4, 0xc0, 0xed, 0x20, 0x4d, 0xf5,
   296  		0x50, 0xab, 0x7c, 0x3a, 0xa8, 0x1e, 0x18, 0x90, 0x16, 0x41, 0xd4, 0x34, 0x05, 0x99, 0xea, 0x9e,
   297  		0x81, 0x14, 0xd5, 0x41, 0xa6, 0xea, 0x96, 0xcf, 0x06, 0x95, 0x4b, 0x9a, 0xd6, 0x20, 0xa3, 0x75,
   298  		0x32, 0x28, 0x3d, 0x0e, 0x93, 0xd6, 0xde, 0x0d, 0x8d, 0x86, 0xa4, 0x62, 0x3b, 0x68, 0x5f, 0x7f,
   299  		0xa9, 0xfc, 0x30, 0xf1, 0xef, 0x04, 0x1e, 0x20, 0x01, 0xb9, 0x4d, 0xc4, 0xd2, 0x63, 0x20, 0x6a,
   300  		0x6e, 0x47, 0x75, 0x6c, 0x92, 0x93, 0x5d, 0x5b, 0xd5, 0x50, 0xf9, 0x11, 0xaa, 0x4a, 0xe5, 0x9b,
   301  		0x5c, 0x8c, 0xb7, 0x84, 0x7b, 0x4b, 0xdf, 0xf7, 0x38, 0xe3, 0xa3, 0x74, 0x4b, 0x10, 0x19, 0x63,
   302  		0x9b, 0x07, 0x11, 0xbb, 0x22, 0xf4, 0xe2, 0x79, 0xa2, 0x56, 0xb2, 0x3b, 0x76, 0xf0, 0xbd, 0x0f,
   303  		0xc1, 0x38, 0xd6, 0xec, 0xbf, 0xf4, 0x31, 0xda, 0x90, 0xd9, 0x9d, 0xc0, 0x1b, 0x2f, 0xc2, 0x0c,
   304  		0x56, 0xea, 0x22, 0x4f, 0x6d, 0xa9, 0x9e, 0x1a, 0xd0, 0xfe, 0x04, 0xd1, 0xc6, 0x7e, 0xdf, 0x60,
   305  		0x83, 0x21, 0x3b, 0x9d, 0xde, 0xde, 0xa1, 0x1f, 0x59, 0x4f, 0x52, 0x3b, 0xb1, 0x8c, 0xc7, 0xd6,
   306  		0x07, 0xd6, 0x74, 0x57, 0x6b, 0x50, 0x0c, 0x06, 0xbe, 0x94, 0x07, 0x1a, 0xfa, 0xa2, 0x80, 0xbb,
   307  		0xa0, 0xe5, 0xad, 0x15, 0xdc, 0xbf, 0xbc, 0xd8, 0x10, 0x53, 0xb8, 0x8f, 0x5a, 0x5f, 0xdb, 0x69,
   308  		0x28, 0xf2, 0xee, 0xe6, 0xce, 0xda, 0x46, 0x43, 0x4c, 0x07, 0x1b, 0xf6, 0xef, 0xa5, 0xa0, 0x14,
   309  		0x3e, 0x7b, 0x49, 0x3f, 0x01, 0xa7, 0xf9, 0x45, 0x89, 0x8b, 0x3c, 0xe5, 0x96, 0xee, 0x90, 0xbd,
   310  		0xd8, 0x55, 0x69, 0x5d, 0xf4, 0xa3, 0x61, 0x9a, 0x69, 0x35, 0x91, 0xf7, 0x9c, 0xee, 0xe0, 0x9d,
   311  		0xd6, 0x55, 0x3d, 0x69, 0x1d, 0xce, 0x9a, 0x96, 0xe2, 0x7a, 0xaa, 0xd9, 0x52, 0x9d, 0x96, 0xd2,
   312  		0xbf, 0xa2, 0x52, 0x54, 0x4d, 0x43, 0xae, 0x6b, 0xd1, 0x1a, 0xe8, 0xb3, 0x7c, 0xcc, 0xb4, 0x9a,
   313  		0x4c, 0xb9, 0x5f, 0x1c, 0xea, 0x4c, 0x35, 0x12, 0xb9, 0xe9, 0xe3, 0x22, 0xf7, 0x01, 0xc8, 0x77,
   314  		0x55, 0x5b, 0x41, 0xa6, 0xe7, 0x1c, 0x92, 0x8e, 0x3b, 0x27, 0xe7, 0xba, 0xaa, 0xdd, 0xc0, 0xcf,
   315  		0x1f, 0xce, 0xc1, 0xe7, 0x5f, 0xd2, 0x50, 0x0c, 0x76, 0xdd, 0xf8, 0x10, 0xa3, 0x91, 0x02, 0x25,
   316  		0x90, 0x14, 0xf6, 0xd0, 0x7d, 0x7b, 0xf4, 0x85, 0x65, 0x5c, 0xb9, 0x6a, 0xa3, 0xb4, 0x17, 0x96,
   317  		0x29, 0x12, 0x77, 0x0d, 0x38, 0xb4, 0x10, 0xed, 0x3d, 0x72, 0x32, 0x7b, 0x92, 0x56, 0x61, 0xf4,
   318  		0x86, 0x4b, 0xb8, 0x47, 0x09, 0xf7, 0xc3, 0xf7, 0xe7, 0x7e, 0xb6, 0x49, 0xc8, 0xf3, 0xcf, 0x36,
   319  		0x95, 0xcd, 0x2d, 0x79, 0xa3, 0xbe, 0x2e, 0x33, 0xb8, 0x74, 0x06, 0x32, 0x86, 0x7a, 0xfb, 0x30,
   320  		0x5c, 0xe3, 0x88, 0x28, 0xa9, 0xe3, 0xcf, 0x40, 0xe6, 0x16, 0x52, 0x0f, 0xc2, 0x95, 0x85, 0x88,
   321  		0x3e, 0xc0, 0xd0, 0x5f, 0x84, 0x2c, 0xf1, 0x97, 0x04, 0xc0, 0x3c, 0x26, 0x8e, 0x48, 0x39, 0xc8,
   322  		0x2c, 0x6f, 0xc9, 0x38, 0xfc, 0x45, 0x28, 0x52, 0xa9, 0xb2, 0xbd, 0xd6, 0x58, 0x6e, 0x88, 0xa9,
   323  		0xea, 0x25, 0x18, 0xa5, 0x4e, 0xc0, 0x5b, 0xc3, 0x77, 0x83, 0x38, 0xc2, 0x1e, 0x19, 0x87, 0xc0,
   324  		0x47, 0x77, 0x37, 0x96, 0x1a, 0xb2, 0x98, 0x0a, 0x2e, 0xaf, 0x0b, 0xc5, 0x60, 0xc3, 0xfd, 0xe1,
   325  		0xc4, 0xd4, 0x77, 0x05, 0x28, 0x04, 0x1a, 0x68, 0xdc, 0xf9, 0xa8, 0x86, 0x61, 0xdd, 0x52, 0x54,
   326  		0x43, 0x57, 0x5d, 0x16, 0x14, 0x40, 0x44, 0x75, 0x2c, 0x49, 0xba, 0x68, 0x1f, 0x8a, 0xf1, 0xaf,
   327  		0x09, 0x20, 0x46, 0x7b, 0xd7, 0x88, 0x81, 0xc2, 0x47, 0x6a, 0xe0, 0xab, 0x02, 0x94, 0xc2, 0x0d,
   328  		0x6b, 0xc4, 0xbc, 0x73, 0x1f, 0xa9, 0x79, 0x6f, 0xa5, 0x60, 0x3c, 0xd4, 0xa6, 0x26, 0xb5, 0xee,
   329  		0xf3, 0x30, 0xa9, 0xb7, 0x50, 0xd7, 0xb6, 0x3c, 0x64, 0x6a, 0x87, 0x8a, 0x81, 0x6e, 0x22, 0xa3,
   330  		0x5c, 0x25, 0x89, 0x62, 0xf1, 0xfe, 0x8d, 0xf0, 0xc2, 0x5a, 0x1f, 0xb7, 0x8e, 0x61, 0xb5, 0xa9,
   331  		0xb5, 0x95, 0xc6, 0xc6, 0xf6, 0xd6, 0x4e, 0x63, 0x73, 0xf9, 0x05, 0x65, 0x77, 0xf3, 0xa7, 0x36,
   332  		0xb7, 0x9e, 0xdb, 0x94, 0x45, 0x3d, 0xa2, 0xf6, 0x01, 0x6e, 0xf5, 0x6d, 0x10, 0xa3, 0x46, 0x49,
   333  		0xa7, 0x61, 0x98, 0x59, 0xe2, 0x88, 0x34, 0x05, 0x13, 0x9b, 0x5b, 0x4a, 0x73, 0x6d, 0xa5, 0xa1,
   334  		0x34, 0xae, 0x5f, 0x6f, 0x2c, 0xef, 0x34, 0xe9, 0xd5, 0x86, 0xaf, 0xbd, 0x13, 0xde, 0xd4, 0xaf,
   335  		0xa4, 0x61, 0x6a, 0x88, 0x25, 0x52, 0x9d, 0x1d, 0x4a, 0xe8, 0x39, 0xe9, 0xc9, 0x24, 0xd6, 0x2f,
   336  		0xe0, 0xae, 0x60, 0x5b, 0x75, 0x3c, 0x76, 0x86, 0x79, 0x0c, 0xb0, 0x97, 0x4c, 0x4f, 0xdf, 0xd7,
   337  		0x91, 0xc3, 0x6e, 0x82, 0xe8, 0x49, 0x65, 0xa2, 0x2f, 0xa7, 0x97, 0x41, 0x9f, 0x00, 0xc9, 0xb6,
   338  		0x5c, 0xdd, 0xd3, 0x6f, 0x22, 0x45, 0x37, 0xf9, 0xb5, 0x11, 0x3e, 0xb9, 0x64, 0x64, 0x91, 0x8f,
   339  		0xac, 0x99, 0x9e, 0xaf, 0x6d, 0xa2, 0xb6, 0x1a, 0xd1, 0xc6, 0x09, 0x3c, 0x2d, 0x8b, 0x7c, 0xc4,
   340  		0xd7, 0x3e, 0x07, 0xc5, 0x96, 0xd5, 0xc3, 0xed, 0x1c, 0xd5, 0xc3, 0xf5, 0x42, 0x90, 0x0b, 0x54,
   341  		0xe6, 0xab, 0xb0, 0x46, 0xbd, 0x7f, 0x5f, 0x55, 0x94, 0x0b, 0x54, 0x46, 0x55, 0x1e, 0x85, 0x09,
   342  		0xb5, 0xdd, 0x76, 0x30, 0x39, 0x27, 0xa2, 0x47, 0x8f, 0x92, 0x2f, 0x26, 0x8a, 0xb3, 0xcf, 0x42,
   343  		0x8e, 0xfb, 0x01, 0x97, 0x64, 0xec, 0x09, 0xc5, 0xa6, 0xe7, 0xe9, 0xd4, 0x7c, 0x5e, 0xce, 0x99,
   344  		0x7c, 0xf0, 0x1c, 0x14, 0x75, 0x57, 0xe9, 0x5f, 0xbf, 0xa7, 0xe6, 0x52, 0xf3, 0x39, 0xb9, 0xa0,
   345  		0xbb, 0xfe, 0xd5, 0x65, 0xf5, 0xf5, 0x14, 0x94, 0xc2, 0x9f, 0x0f, 0xa4, 0x15, 0xc8, 0x19, 0x96,
   346  		0xa6, 0x92, 0xd0, 0xa2, 0xdf, 0xae, 0xe6, 0x63, 0xbe, 0x38, 0x2c, 0xac, 0x33, 0x7d, 0xd9, 0x47,
   347  		0xce, 0xfe, 0x93, 0x00, 0x39, 0x2e, 0x96, 0x66, 0x20, 0x63, 0xab, 0x5e, 0x87, 0xd0, 0x65, 0x97,
   348  		0x52, 0xa2, 0x20, 0x93, 0x67, 0x2c, 0x77, 0x6d, 0xd5, 0x24, 0x21, 0xc0, 0xe4, 0xf8, 0x19, 0xaf,
   349  		0xab, 0x81, 0xd4, 0x16, 0x39, 0xd7, 0x58, 0xdd, 0x2e, 0x32, 0x3d, 0x97, 0xaf, 0x2b, 0x93, 0x2f,
   350  		0x33, 0xb1, 0xf4, 0x04, 0x4c, 0x7a, 0x8e, 0xaa, 0x1b, 0x21, 0xdd, 0x0c, 0xd1, 0x15, 0xf9, 0x80,
   351  		0xaf, 0x5c, 0x83, 0x33, 0x9c, 0xb7, 0x85, 0x3c, 0x55, 0xeb, 0xa0, 0x56, 0x1f, 0x34, 0x4a, 0xee,
   352  		0x2f, 0x4e, 0x33, 0x85, 0x15, 0x36, 0xce, 0xb1, 0xd5, 0x1f, 0x08, 0x30, 0xc9, 0x4f, 0x62, 0x2d,
   353  		0xdf, 0x59, 0x1b, 0x00, 0xaa, 0x69, 0x5a, 0x5e, 0xd0, 0x5d, 0x83, 0xa1, 0x3c, 0x80, 0x5b, 0xa8,
   354  		0xfb, 0x20, 0x39, 0x40, 0x30, 0xdb, 0x05, 0xe8, 0x8f, 0x1c, 0xeb, 0xb6, 0xb3, 0x50, 0x60, 0xdf,
   355  		0x86, 0xc8, 0x07, 0x46, 0x7a, 0x76, 0x07, 0x2a, 0xc2, 0x47, 0x36, 0x69, 0x1a, 0xb2, 0x7b, 0xa8,
   356  		0xad, 0x9b, 0xec, 0xc6, 0x97, 0x3e, 0xf0, 0x1b, 0x96, 0x8c, 0x7f, 0xc3, 0xb2, 0xf4, 0x39, 0x98,
   357  		0xd2, 0xac, 0x6e, 0xd4, 0xdc, 0x25, 0x31, 0x72, 0x7f, 0xe0, 0x7e, 0x5a, 0x78, 0x11, 0xfa, 0x2d,
   358  		0xe6, 0x7b, 0x82, 0xf0, 0xd5, 0x54, 0x7a, 0x75, 0x7b, 0xe9, 0x1b, 0xa9, 0xd9, 0x55, 0x0a, 0xdd,
   359  		0xe6, 0x33, 0x95, 0xd1, 0xbe, 0x81, 0x34, 0x6c, 0x3d, 0x7c, 0xed, 0x09, 0x78, 0xb2, 0xad, 0x7b,
   360  		0x9d, 0xde, 0xde, 0x82, 0x66, 0x75, 0x17, 0xdb, 0x56, 0xdb, 0xea, 0x7f, 0x53, 0xc5, 0x4f, 0xe4,
   361  		0x81, 0xfc, 0xc7, 0xbe, 0xab, 0xe6, 0x7d, 0xe9, 0x6c, 0xec, 0x47, 0xd8, 0xda, 0x26, 0x4c, 0x31,
   362  		0x65, 0x85, 0x7c, 0xd8, 0xa1, 0xc7, 0x13, 0xe9, 0xbe, 0x97, 0x63, 0xe5, 0x6f, 0xbe, 0x4d, 0xca,
   363  		0xb5, 0x3c, 0xc9, 0xa0, 0x78, 0x8c, 0x9e, 0x60, 0x6a, 0x32, 0x9c, 0x0a, 0xf1, 0xd1, 0xad, 0x89,
   364  		0x9c, 0x18, 0xc6, 0xef, 0x31, 0xc6, 0xa9, 0x00, 0x63, 0x93, 0x41, 0x6b, 0xcb, 0x30, 0x7e, 0x12,
   365  		0xae, 0x7f, 0x60, 0x5c, 0x45, 0x14, 0x24, 0x59, 0x85, 0x09, 0x42, 0xa2, 0xf5, 0x5c, 0xcf, 0xea,
   366  		0x92, 0xbc, 0x77, 0x7f, 0x9a, 0x7f, 0x7c, 0x9b, 0xee, 0x95, 0x12, 0x86, 0x2d, 0xfb, 0xa8, 0x5a,
   367  		0x0d, 0xc8, 0xb7, 0xac, 0x16, 0xd2, 0x8c, 0x18, 0x86, 0x37, 0x99, 0x21, 0xbe, 0x7e, 0xed, 0xb3,
   368  		0x30, 0x8d, 0xff, 0x27, 0x69, 0x29, 0x68, 0x49, 0xfc, 0x4d, 0x5a, 0xf9, 0x07, 0x2f, 0xd3, 0xed,
   369  		0x38, 0xe5, 0x13, 0x04, 0x6c, 0x0a, 0xac, 0x62, 0x1b, 0x79, 0x1e, 0x72, 0x5c, 0x45, 0x35, 0x86,
   370  		0x99, 0x17, 0xb8, 0x8a, 0x28, 0x7f, 0xe9, 0x9d, 0xf0, 0x2a, 0xae, 0x52, 0x64, 0xdd, 0x30, 0x6a,
   371  		0xbb, 0x70, 0x7a, 0x48, 0x54, 0x24, 0xe0, 0x7c, 0x85, 0x71, 0x4e, 0x0f, 0x44, 0x06, 0xa6, 0xdd,
   372  		0x06, 0x2e, 0xf7, 0xd7, 0x32, 0x01, 0xe7, 0xef, 0x31, 0x4e, 0x89, 0x61, 0xf9, 0x92, 0x62, 0xc6,
   373  		0x67, 0x61, 0xf2, 0x26, 0x72, 0xf6, 0x2c, 0x97, 0x5d, 0xff, 0x24, 0xa0, 0x7b, 0x95, 0xd1, 0x4d,
   374  		0x30, 0x20, 0xb9, 0x0f, 0xc2, 0x5c, 0x57, 0x21, 0xb7, 0xaf, 0x6a, 0x28, 0x01, 0xc5, 0x97, 0x19,
   375  		0xc5, 0x18, 0xd6, 0xc7, 0xd0, 0x3a, 0x14, 0xdb, 0x16, 0xab, 0x4c, 0xf1, 0xf0, 0xd7, 0x18, 0xbc,
   376  		0xc0, 0x31, 0x8c, 0xc2, 0xb6, 0xec, 0x9e, 0x81, 0xcb, 0x56, 0x3c, 0xc5, 0xef, 0x73, 0x0a, 0x8e,
   377  		0x61, 0x14, 0x27, 0x70, 0xeb, 0x1f, 0x70, 0x0a, 0x37, 0xe0, 0xcf, 0x67, 0xa0, 0x60, 0x99, 0xc6,
   378  		0xa1, 0x65, 0x26, 0x31, 0xe2, 0x2b, 0x8c, 0x01, 0x18, 0x04, 0x13, 0x5c, 0x83, 0x7c, 0xd2, 0x85,
   379  		0xf8, 0xa3, 0x77, 0xf8, 0xf6, 0xe0, 0x2b, 0xb0, 0x0a, 0x13, 0x3c, 0x41, 0xe9, 0x96, 0x99, 0x80,
   380  		0xe2, 0x6b, 0x8c, 0xa2, 0x14, 0x80, 0xb1, 0x69, 0x78, 0xc8, 0xf5, 0xda, 0x28, 0x09, 0xc9, 0xeb,
   381  		0x7c, 0x1a, 0x0c, 0xc2, 0x5c, 0xb9, 0x87, 0x4c, 0xad, 0x93, 0x8c, 0xe1, 0xeb, 0xdc, 0x95, 0x1c,
   382  		0x83, 0x29, 0x96, 0x61, 0xbc, 0xab, 0x3a, 0x6e, 0x47, 0x35, 0x12, 0x2d, 0xc7, 0x1f, 0x33, 0x8e,
   383  		0xa2, 0x0f, 0x62, 0x1e, 0xe9, 0x99, 0x27, 0xa1, 0xf9, 0x06, 0xf7, 0x48, 0x00, 0xc6, 0xb6, 0x9e,
   384  		0xeb, 0x91, 0xbb, 0xb2, 0x93, 0xb0, 0xfd, 0x09, 0xdf, 0x7a, 0x14, 0xbb, 0x11, 0x64, 0xbc, 0x06,
   385  		0x79, 0x57, 0xbf, 0x9d, 0x88, 0xe6, 0x4f, 0xf9, 0x4a, 0x13, 0x00, 0x06, 0xbf, 0x00, 0x67, 0x86,
   386  		0x96, 0x89, 0x04, 0x64, 0x7f, 0xc6, 0xc8, 0x66, 0x86, 0x94, 0x0a, 0x96, 0x12, 0x4e, 0x4a, 0xf9,
   387  		0xe7, 0x3c, 0x25, 0xa0, 0x08, 0xd7, 0x36, 0x3e, 0x2b, 0xb8, 0xea, 0xfe, 0xc9, 0xbc, 0xf6, 0x17,
   388  		0xdc, 0x6b, 0x14, 0x1b, 0xf2, 0xda, 0x0e, 0xcc, 0x30, 0xc6, 0x93, 0xad, 0xeb, 0x1b, 0x3c, 0xb1,
   389  		0x52, 0xf4, 0x6e, 0x78, 0x75, 0x3f, 0x07, 0xb3, 0xbe, 0x3b, 0x79, 0x53, 0xea, 0x2a, 0x5d, 0xd5,
   390  		0x4e, 0xc0, 0xfc, 0x4d, 0xc6, 0xcc, 0x33, 0xbe, 0xdf, 0xd5, 0xba, 0x1b, 0xaa, 0x8d, 0xc9, 0x9f,
   391  		0x87, 0x32, 0x27, 0xef, 0x99, 0x0e, 0xd2, 0xac, 0xb6, 0xa9, 0xdf, 0x46, 0xad, 0x04, 0xd4, 0x7f,
   392  		0x19, 0x59, 0xaa, 0xdd, 0x00, 0x1c, 0x33, 0xaf, 0x81, 0xe8, 0xf7, 0x2a, 0x8a, 0xde, 0xb5, 0x2d,
   393  		0xc7, 0x8b, 0x61, 0xfc, 0x2b, 0xbe, 0x52, 0x3e, 0x6e, 0x8d, 0xc0, 0x6a, 0x0d, 0x28, 0x91, 0xc7,
   394  		0xa4, 0x21, 0xf9, 0xd7, 0x8c, 0x68, 0xbc, 0x8f, 0x62, 0x89, 0x43, 0xb3, 0xba, 0xb6, 0xea, 0x24,
   395  		0xc9, 0x7f, 0x7f, 0xc3, 0x13, 0x07, 0x83, 0xb0, 0xc4, 0xe1, 0x1d, 0xda, 0x08, 0x57, 0xfb, 0x04,
   396  		0x0c, 0xdf, 0xe2, 0x89, 0x83, 0x63, 0x18, 0x05, 0x6f, 0x18, 0x12, 0x50, 0xfc, 0x2d, 0xa7, 0xe0,
   397  		0x18, 0x4c, 0xf1, 0x99, 0x7e, 0xa1, 0x75, 0x50, 0x5b, 0x77, 0x3d, 0x87, 0xb6, 0xc2, 0xf7, 0xa7,
   398  		0xfa, 0xf6, 0x3b, 0xe1, 0x26, 0x4c, 0x0e, 0x40, 0x71, 0x26, 0x62, 0x57, 0xa8, 0xe4, 0xa4, 0x14,
   399  		0x6f, 0xd8, 0x77, 0x78, 0x26, 0x0a, 0xc0, 0xb0, 0x6d, 0x81, 0x0e, 0x11, 0xbb, 0x5d, 0xc3, 0xe7,
   400  		0x83, 0x04, 0x74, 0xdf, 0x8d, 0x18, 0xd7, 0xe4, 0x58, 0xcc, 0x19, 0xe8, 0x7f, 0x7a, 0xe6, 0x01,
   401  		0x3a, 0x4c, 0x14, 0x9d, 0x7f, 0x17, 0xe9, 0x7f, 0x76, 0x29, 0x92, 0xe6, 0x90, 0x89, 0x48, 0x3f,
   402  		0x25, 0xc5, 0xfd, 0x0a, 0xa8, 0xfc, 0x73, 0xf7, 0xd8, 0x7c, 0xc3, 0xed, 0x54, 0x6d, 0x1d, 0x07,
   403  		0x79, 0xb8, 0xe9, 0x89, 0x27, 0x7b, 0xf9, 0x9e, 0x1f, 0xe7, 0xa1, 0x9e, 0xa7, 0x76, 0x1d, 0xc6,
   404  		0x43, 0x0d, 0x4f, 0x3c, 0xd5, 0xcf, 0x33, 0xaa, 0x62, 0xb0, 0xdf, 0xa9, 0x5d, 0x82, 0x0c, 0x6e,
   405  		0x5e, 0xe2, 0xe1, 0xbf, 0xc0, 0xe0, 0x44, 0xbd, 0xf6, 0x29, 0xc8, 0xf1, 0xa6, 0x25, 0x1e, 0xfa,
   406  		0x8b, 0x0c, 0xea, 0x43, 0x30, 0x9c, 0x37, 0x2c, 0xf1, 0xf0, 0x5f, 0xe2, 0x70, 0x0e, 0xc1, 0xf0,
   407  		0xe4, 0x2e, 0xfc, 0xfb, 0x5f, 0xce, 0xb0, 0xa2, 0xc3, 0x7d, 0x77, 0x0d, 0xc6, 0x58, 0xa7, 0x12,
   408  		0x8f, 0xfe, 0x02, 0x7b, 0x39, 0x47, 0xd4, 0x9e, 0x82, 0x6c, 0x42, 0x87, 0xff, 0x2a, 0x83, 0x52,
   409  		0xfd, 0xda, 0x32, 0x14, 0x02, 0xdd, 0x49, 0x3c, 0xfc, 0xd7, 0x18, 0x3c, 0x88, 0xc2, 0xa6, 0xb3,
   410  		0xee, 0x24, 0x9e, 0xe0, 0xd7, 0xb9, 0xe9, 0x0c, 0x81, 0xdd, 0xc6, 0x1b, 0x93, 0x78, 0xf4, 0x6f,
   411  		0x70, 0xaf, 0x73, 0x48, 0xed, 0x19, 0xc8, 0xfb, 0xc5, 0x26, 0x1e, 0xff, 0x9b, 0x0c, 0xdf, 0xc7,
   412  		0x60, 0x0f, 0x04, 0x8a, 0x5d, 0x3c, 0xc5, 0x6f, 0x71, 0x0f, 0x04, 0x50, 0x78, 0x1b, 0x45, 0x1b,
   413  		0x98, 0x78, 0xa6, 0xdf, 0xe6, 0xdb, 0x28, 0xd2, 0xbf, 0xe0, 0xd5, 0x24, 0x39, 0x3f, 0x9e, 0xe2,
   414  		0x77, 0xf8, 0x6a, 0x12, 0x7d, 0x6c, 0x46, 0xb4, 0x23, 0x88, 0xe7, 0xf8, 0x5d, 0x6e, 0x46, 0xa4,
   415  		0x21, 0xa8, 0x6d, 0x83, 0x34, 0xd8, 0x0d, 0xc4, 0xf3, 0x7d, 0x91, 0xf1, 0x4d, 0x0e, 0x34, 0x03,
   416  		0xb5, 0xe7, 0x60, 0x66, 0x78, 0x27, 0x10, 0xcf, 0xfa, 0xa5, 0x7b, 0x91, 0xb3, 0x5b, 0xb0, 0x11,
   417  		0xa8, 0xed, 0xf4, 0x4b, 0x4a, 0xb0, 0x0b, 0x88, 0xa7, 0x7d, 0xe5, 0x5e, 0x38, 0x71, 0x07, 0x9b,
   418  		0x80, 0x5a, 0x1d, 0xa0, 0x5f, 0x80, 0xe3, 0xb9, 0x5e, 0x65, 0x5c, 0x01, 0x10, 0xde, 0x1a, 0xac,
   419  		0xfe, 0xc6, 0xe3, 0xbf, 0xcc, 0xb7, 0x06, 0x43, 0xe0, 0xad, 0xc1, 0x4b, 0x6f, 0x3c, 0xfa, 0x35,
   420  		0xbe, 0x35, 0x38, 0x04, 0x47, 0x76, 0xa0, 0xba, 0xc5, 0x33, 0x7c, 0x85, 0x47, 0x76, 0x00, 0x55,
   421  		0xdb, 0x84, 0xc9, 0x81, 0x82, 0x18, 0x4f, 0xf5, 0x55, 0x46, 0x25, 0x46, 0xeb, 0x61, 0xb0, 0x78,
   422  		0xb1, 0x62, 0x18, 0xcf, 0xf6, 0x87, 0x91, 0xe2, 0xc5, 0x6a, 0x61, 0xed, 0x1a, 0xe4, 0xcc, 0x9e,
   423  		0x61, 0xe0, 0xcd, 0x23, 0xdd, 0xff, 0x97, 0x7b, 0xe5, 0x7f, 0x7b, 0x9f, 0x79, 0x87, 0x03, 0x6a,
   424  		0x97, 0x20, 0x8b, 0xba, 0x7b, 0xa8, 0x15, 0x87, 0xfc, 0xf7, 0xf7, 0x79, 0xc2, 0xc4, 0xda, 0xb5,
   425  		0x67, 0x00, 0xe8, 0xd5, 0x08, 0xf9, 0xec, 0x17, 0x83, 0xfd, 0x8f, 0xf7, 0xd9, 0x6f, 0x6a, 0xfa,
   426  		0x90, 0x3e, 0x01, 0xfd, 0x85, 0xce, 0xfd, 0x09, 0xde, 0x09, 0x13, 0x90, 0x15, 0xb9, 0x0a, 0x63,
   427  		0x37, 0x5c, 0xcb, 0xf4, 0xd4, 0x76, 0x1c, 0xfa, 0x3f, 0x19, 0x9a, 0xeb, 0x63, 0x87, 0x75, 0x2d,
   428  		0x07, 0x79, 0x6a, 0xdb, 0x8d, 0xc3, 0xfe, 0x17, 0xc3, 0xfa, 0x00, 0x0c, 0xd6, 0x54, 0xd7, 0x4b,
   429  		0x32, 0xef, 0xff, 0xe6, 0x60, 0x0e, 0xc0, 0x46, 0xe3, 0xff, 0x0f, 0xd0, 0x61, 0x1c, 0xf6, 0x5d,
   430  		0x6e, 0x34, 0xd3, 0xaf, 0x7d, 0x0a, 0xf2, 0xf8, 0x5f, 0xfa, 0x43, 0xb9, 0x18, 0xf0, 0xff, 0x30,
   431  		0x70, 0x1f, 0x81, 0xdf, 0xec, 0x7a, 0x2d, 0x4f, 0x8f, 0x77, 0xf6, 0xff, 0xb2, 0x95, 0xe6, 0xfa,
   432  		0xb5, 0x3a, 0x14, 0x5c, 0xaf, 0xd5, 0xea, 0xb1, 0xfe, 0x34, 0x06, 0xfe, 0x7f, 0xef, 0xfb, 0x57,
   433  		0x16, 0x3e, 0x06, 0xaf, 0xf6, 0xad, 0x03, 0xcf, 0xb6, 0xc8, 0x67, 0x8e, 0x38, 0x86, 0x7b, 0x8c,
   434  		0x21, 0x00, 0x59, 0x6a, 0x0c, 0xbf, 0xbe, 0x85, 0x55, 0x6b, 0xd5, 0xa2, 0x17, 0xb7, 0x2f, 0x56,
   435  		0xe3, 0x6f, 0x60, 0xe1, 0x8d, 0x34, 0x9c, 0xd2, 0xac, 0xee, 0x9e, 0xe5, 0x2e, 0xee, 0x59, 0x5e,
   436  		0x67, 0xb1, 0xab, 0xda, 0xec, 0x42, 0xb6, 0xd0, 0x55, 0x6d, 0xf6, 0x93, 0x5a, 0x77, 0xf6, 0x64,
   437  		0x97, 0xb9, 0xd5, 0x9f, 0x85, 0xb1, 0x0d, 0xd5, 0xde, 0x41, 0xae, 0x27, 0x11, 0x37, 0x93, 0xdf,
   438  		0x6e, 0xb1, 0x1b, 0xf2, 0xb9, 0x85, 0x00, 0xf1, 0x02, 0x53, 0x5b, 0x68, 0x7a, 0x4e, 0xd3, 0x73,
   439  		0xc8, 0xaf, 0x09, 0xe4, 0x51, 0x97, 0x3c, 0xcc, 0x5e, 0x85, 0x42, 0x40, 0x2c, 0x89, 0x90, 0x3e,
   440  		0x40, 0x87, 0xec, 0xd7, 0x5b, 0xf8, 0x5f, 0x69, 0xba, 0xff, 0xf3, 0x4a, 0x2c, 0xa3, 0x0f, 0xb5,
   441  		0xd4, 0x15, 0xa1, 0xfa, 0x34, 0x8c, 0x5d, 0x57, 0x0f, 0xd0, 0x86, 0x6a, 0x4b, 0x17, 0x60, 0x0c,
   442  		0x99, 0x9e, 0xa3, 0x23, 0x97, 0x19, 0x70, 0x26, 0x64, 0x00, 0x53, 0xa3, 0x6f, 0xe6, 0x9a, 0xd5,
   443  		0x75, 0x28, 0x06, 0x07, 0x92, 0xbe, 0x1b, 0x4b, 0x2d, 0xaf, 0xc3, 0x7e, 0x6e, 0x9d, 0x97, 0xe9,
   444  		0xc3, 0xd2, 0xca, 0x9b, 0x77, 0x2b, 0x23, 0xdf, 0xbf, 0x5b, 0x19, 0xf9, 0xe7, 0xbb, 0x95, 0x91,
   445  		0xb7, 0xee, 0x56, 0x84, 0x77, 0xef, 0x56, 0x84, 0xf7, 0xee, 0x56, 0x84, 0x3b, 0x47, 0x15, 0xe1,
   446  		0xeb, 0x47, 0x15, 0xe1, 0x8d, 0xa3, 0x8a, 0xf0, 0xed, 0xa3, 0x8a, 0xf0, 0xe6, 0x51, 0x45, 0xf8,
   447  		0xfe, 0x51, 0x45, 0x78, 0xeb, 0xa8, 0x22, 0xfc, 0xe8, 0xa8, 0x32, 0xf2, 0xee, 0x51, 0x45, 0x78,
   448  		0xef, 0xa8, 0x32, 0x72, 0xe7, 0x87, 0x95, 0x91, 0xbd, 0x51, 0xe2, 0xdb, 0x0b, 0xff, 0x1f, 0x00,
   449  		0x00, 0xff, 0xff, 0x8e, 0xa9, 0xe9, 0xc6, 0xa7, 0x34, 0x00, 0x00,
   450  	}
   451  	r := bytes.NewReader(gzipped)
   452  	gzipr, err := compress_gzip.NewReader(r)
   453  	if err != nil {
   454  		panic(err)
   455  	}
   456  	ungzipped, err := io_ioutil.ReadAll(gzipr)
   457  	if err != nil {
   458  		panic(err)
   459  	}
   460  	if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
   461  		panic(err)
   462  	}
   463  	return d
   464  }
   465  func (this *MapTest) VerboseEqual(that interface{}) error {
   466  	if that == nil {
   467  		if this == nil {
   468  			return nil
   469  		}
   470  		return fmt.Errorf("that == nil && this != nil")
   471  	}
   472  
   473  	that1, ok := that.(*MapTest)
   474  	if !ok {
   475  		that2, ok := that.(MapTest)
   476  		if ok {
   477  			that1 = &that2
   478  		} else {
   479  			return fmt.Errorf("that is not of type *MapTest")
   480  		}
   481  	}
   482  	if that1 == nil {
   483  		if this == nil {
   484  			return nil
   485  		}
   486  		return fmt.Errorf("that is type *MapTest but is nil && this != nil")
   487  	} else if this == nil {
   488  		return fmt.Errorf("that is type *MapTest but is not nil && this == nil")
   489  	}
   490  	if len(this.StrStr) != len(that1.StrStr) {
   491  		return fmt.Errorf("StrStr this(%v) Not Equal that(%v)", len(this.StrStr), len(that1.StrStr))
   492  	}
   493  	for i := range this.StrStr {
   494  		if this.StrStr[i] != that1.StrStr[i] {
   495  			return fmt.Errorf("StrStr this[%v](%v) Not Equal that[%v](%v)", i, this.StrStr[i], i, that1.StrStr[i])
   496  		}
   497  	}
   498  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   499  		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
   500  	}
   501  	return nil
   502  }
   503  func (this *MapTest) Equal(that interface{}) bool {
   504  	if that == nil {
   505  		return this == nil
   506  	}
   507  
   508  	that1, ok := that.(*MapTest)
   509  	if !ok {
   510  		that2, ok := that.(MapTest)
   511  		if ok {
   512  			that1 = &that2
   513  		} else {
   514  			return false
   515  		}
   516  	}
   517  	if that1 == nil {
   518  		return this == nil
   519  	} else if this == nil {
   520  		return false
   521  	}
   522  	if len(this.StrStr) != len(that1.StrStr) {
   523  		return false
   524  	}
   525  	for i := range this.StrStr {
   526  		if this.StrStr[i] != that1.StrStr[i] {
   527  			return false
   528  		}
   529  	}
   530  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   531  		return false
   532  	}
   533  	return true
   534  }
   535  func (this *FakeMap) VerboseEqual(that interface{}) error {
   536  	if that == nil {
   537  		if this == nil {
   538  			return nil
   539  		}
   540  		return fmt.Errorf("that == nil && this != nil")
   541  	}
   542  
   543  	that1, ok := that.(*FakeMap)
   544  	if !ok {
   545  		that2, ok := that.(FakeMap)
   546  		if ok {
   547  			that1 = &that2
   548  		} else {
   549  			return fmt.Errorf("that is not of type *FakeMap")
   550  		}
   551  	}
   552  	if that1 == nil {
   553  		if this == nil {
   554  			return nil
   555  		}
   556  		return fmt.Errorf("that is type *FakeMap but is nil && this != nil")
   557  	} else if this == nil {
   558  		return fmt.Errorf("that is type *FakeMap but is not nil && this == nil")
   559  	}
   560  	if len(this.Entries) != len(that1.Entries) {
   561  		return fmt.Errorf("Entries this(%v) Not Equal that(%v)", len(this.Entries), len(that1.Entries))
   562  	}
   563  	for i := range this.Entries {
   564  		if !this.Entries[i].Equal(that1.Entries[i]) {
   565  			return fmt.Errorf("Entries this[%v](%v) Not Equal that[%v](%v)", i, this.Entries[i], i, that1.Entries[i])
   566  		}
   567  	}
   568  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   569  		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
   570  	}
   571  	return nil
   572  }
   573  func (this *FakeMap) Equal(that interface{}) bool {
   574  	if that == nil {
   575  		return this == nil
   576  	}
   577  
   578  	that1, ok := that.(*FakeMap)
   579  	if !ok {
   580  		that2, ok := that.(FakeMap)
   581  		if ok {
   582  			that1 = &that2
   583  		} else {
   584  			return false
   585  		}
   586  	}
   587  	if that1 == nil {
   588  		return this == nil
   589  	} else if this == nil {
   590  		return false
   591  	}
   592  	if len(this.Entries) != len(that1.Entries) {
   593  		return false
   594  	}
   595  	for i := range this.Entries {
   596  		if !this.Entries[i].Equal(that1.Entries[i]) {
   597  			return false
   598  		}
   599  	}
   600  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   601  		return false
   602  	}
   603  	return true
   604  }
   605  func (this *FakeMapEntry) VerboseEqual(that interface{}) error {
   606  	if that == nil {
   607  		if this == nil {
   608  			return nil
   609  		}
   610  		return fmt.Errorf("that == nil && this != nil")
   611  	}
   612  
   613  	that1, ok := that.(*FakeMapEntry)
   614  	if !ok {
   615  		that2, ok := that.(FakeMapEntry)
   616  		if ok {
   617  			that1 = &that2
   618  		} else {
   619  			return fmt.Errorf("that is not of type *FakeMapEntry")
   620  		}
   621  	}
   622  	if that1 == nil {
   623  		if this == nil {
   624  			return nil
   625  		}
   626  		return fmt.Errorf("that is type *FakeMapEntry but is nil && this != nil")
   627  	} else if this == nil {
   628  		return fmt.Errorf("that is type *FakeMapEntry but is not nil && this == nil")
   629  	}
   630  	if this.Key != that1.Key {
   631  		return fmt.Errorf("Key this(%v) Not Equal that(%v)", this.Key, that1.Key)
   632  	}
   633  	if this.Value != that1.Value {
   634  		return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value)
   635  	}
   636  	if this.Other != that1.Other {
   637  		return fmt.Errorf("Other this(%v) Not Equal that(%v)", this.Other, that1.Other)
   638  	}
   639  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   640  		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
   641  	}
   642  	return nil
   643  }
   644  func (this *FakeMapEntry) Equal(that interface{}) bool {
   645  	if that == nil {
   646  		return this == nil
   647  	}
   648  
   649  	that1, ok := that.(*FakeMapEntry)
   650  	if !ok {
   651  		that2, ok := that.(FakeMapEntry)
   652  		if ok {
   653  			that1 = &that2
   654  		} else {
   655  			return false
   656  		}
   657  	}
   658  	if that1 == nil {
   659  		return this == nil
   660  	} else if this == nil {
   661  		return false
   662  	}
   663  	if this.Key != that1.Key {
   664  		return false
   665  	}
   666  	if this.Value != that1.Value {
   667  		return false
   668  	}
   669  	if this.Other != that1.Other {
   670  		return false
   671  	}
   672  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   673  		return false
   674  	}
   675  	return true
   676  }
   677  func (this *MapTest) GoString() string {
   678  	if this == nil {
   679  		return "nil"
   680  	}
   681  	s := make([]string, 0, 5)
   682  	s = append(s, "&mapdefaults.MapTest{")
   683  	keysForStrStr := make([]string, 0, len(this.StrStr))
   684  	for k := range this.StrStr {
   685  		keysForStrStr = append(keysForStrStr, k)
   686  	}
   687  	github_com_gogo_protobuf_sortkeys.Strings(keysForStrStr)
   688  	mapStringForStrStr := "map[string]string{"
   689  	for _, k := range keysForStrStr {
   690  		mapStringForStrStr += fmt.Sprintf("%#v: %#v,", k, this.StrStr[k])
   691  	}
   692  	mapStringForStrStr += "}"
   693  	if this.StrStr != nil {
   694  		s = append(s, "StrStr: "+mapStringForStrStr+",\n")
   695  	}
   696  	if this.XXX_unrecognized != nil {
   697  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
   698  	}
   699  	s = append(s, "}")
   700  	return strings.Join(s, "")
   701  }
   702  func (this *FakeMap) GoString() string {
   703  	if this == nil {
   704  		return "nil"
   705  	}
   706  	s := make([]string, 0, 5)
   707  	s = append(s, "&mapdefaults.FakeMap{")
   708  	if this.Entries != nil {
   709  		s = append(s, "Entries: "+fmt.Sprintf("%#v", this.Entries)+",\n")
   710  	}
   711  	if this.XXX_unrecognized != nil {
   712  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
   713  	}
   714  	s = append(s, "}")
   715  	return strings.Join(s, "")
   716  }
   717  func (this *FakeMapEntry) GoString() string {
   718  	if this == nil {
   719  		return "nil"
   720  	}
   721  	s := make([]string, 0, 7)
   722  	s = append(s, "&mapdefaults.FakeMapEntry{")
   723  	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
   724  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
   725  	s = append(s, "Other: "+fmt.Sprintf("%#v", this.Other)+",\n")
   726  	if this.XXX_unrecognized != nil {
   727  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
   728  	}
   729  	s = append(s, "}")
   730  	return strings.Join(s, "")
   731  }
   732  func valueToGoStringMap(v interface{}, typ string) string {
   733  	rv := reflect.ValueOf(v)
   734  	if rv.IsNil() {
   735  		return "nil"
   736  	}
   737  	pv := reflect.Indirect(rv).Interface()
   738  	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
   739  }
   740  func (m *MapTest) Marshal() (dAtA []byte, err error) {
   741  	size := m.Size()
   742  	dAtA = make([]byte, size)
   743  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   744  	if err != nil {
   745  		return nil, err
   746  	}
   747  	return dAtA[:n], nil
   748  }
   749  
   750  func (m *MapTest) MarshalTo(dAtA []byte) (int, error) {
   751  	size := m.Size()
   752  	return m.MarshalToSizedBuffer(dAtA[:size])
   753  }
   754  
   755  func (m *MapTest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   756  	i := len(dAtA)
   757  	_ = i
   758  	var l int
   759  	_ = l
   760  	if m.XXX_unrecognized != nil {
   761  		i -= len(m.XXX_unrecognized)
   762  		copy(dAtA[i:], m.XXX_unrecognized)
   763  	}
   764  	if len(m.StrStr) > 0 {
   765  		for k := range m.StrStr {
   766  			v := m.StrStr[k]
   767  			baseI := i
   768  			i -= len(v)
   769  			copy(dAtA[i:], v)
   770  			i = encodeVarintMap(dAtA, i, uint64(len(v)))
   771  			i--
   772  			dAtA[i] = 0x12
   773  			i -= len(k)
   774  			copy(dAtA[i:], k)
   775  			i = encodeVarintMap(dAtA, i, uint64(len(k)))
   776  			i--
   777  			dAtA[i] = 0xa
   778  			i = encodeVarintMap(dAtA, i, uint64(baseI-i))
   779  			i--
   780  			dAtA[i] = 0xa
   781  		}
   782  	}
   783  	return len(dAtA) - i, nil
   784  }
   785  
   786  func (m *FakeMap) Marshal() (dAtA []byte, err error) {
   787  	size := m.Size()
   788  	dAtA = make([]byte, size)
   789  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   790  	if err != nil {
   791  		return nil, err
   792  	}
   793  	return dAtA[:n], nil
   794  }
   795  
   796  func (m *FakeMap) MarshalTo(dAtA []byte) (int, error) {
   797  	size := m.Size()
   798  	return m.MarshalToSizedBuffer(dAtA[:size])
   799  }
   800  
   801  func (m *FakeMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   802  	i := len(dAtA)
   803  	_ = i
   804  	var l int
   805  	_ = l
   806  	if m.XXX_unrecognized != nil {
   807  		i -= len(m.XXX_unrecognized)
   808  		copy(dAtA[i:], m.XXX_unrecognized)
   809  	}
   810  	if len(m.Entries) > 0 {
   811  		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
   812  			{
   813  				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   814  				if err != nil {
   815  					return 0, err
   816  				}
   817  				i -= size
   818  				i = encodeVarintMap(dAtA, i, uint64(size))
   819  			}
   820  			i--
   821  			dAtA[i] = 0xa
   822  		}
   823  	}
   824  	return len(dAtA) - i, nil
   825  }
   826  
   827  func (m *FakeMapEntry) Marshal() (dAtA []byte, err error) {
   828  	size := m.Size()
   829  	dAtA = make([]byte, size)
   830  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   831  	if err != nil {
   832  		return nil, err
   833  	}
   834  	return dAtA[:n], nil
   835  }
   836  
   837  func (m *FakeMapEntry) MarshalTo(dAtA []byte) (int, error) {
   838  	size := m.Size()
   839  	return m.MarshalToSizedBuffer(dAtA[:size])
   840  }
   841  
   842  func (m *FakeMapEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   843  	i := len(dAtA)
   844  	_ = i
   845  	var l int
   846  	_ = l
   847  	if m.XXX_unrecognized != nil {
   848  		i -= len(m.XXX_unrecognized)
   849  		copy(dAtA[i:], m.XXX_unrecognized)
   850  	}
   851  	if len(m.Other) > 0 {
   852  		i -= len(m.Other)
   853  		copy(dAtA[i:], m.Other)
   854  		i = encodeVarintMap(dAtA, i, uint64(len(m.Other)))
   855  		i--
   856  		dAtA[i] = 0x1a
   857  	}
   858  	if len(m.Value) > 0 {
   859  		i -= len(m.Value)
   860  		copy(dAtA[i:], m.Value)
   861  		i = encodeVarintMap(dAtA, i, uint64(len(m.Value)))
   862  		i--
   863  		dAtA[i] = 0x12
   864  	}
   865  	if len(m.Key) > 0 {
   866  		i -= len(m.Key)
   867  		copy(dAtA[i:], m.Key)
   868  		i = encodeVarintMap(dAtA, i, uint64(len(m.Key)))
   869  		i--
   870  		dAtA[i] = 0xa
   871  	}
   872  	return len(dAtA) - i, nil
   873  }
   874  
   875  func encodeVarintMap(dAtA []byte, offset int, v uint64) int {
   876  	offset -= sovMap(v)
   877  	base := offset
   878  	for v >= 1<<7 {
   879  		dAtA[offset] = uint8(v&0x7f | 0x80)
   880  		v >>= 7
   881  		offset++
   882  	}
   883  	dAtA[offset] = uint8(v)
   884  	return base
   885  }
   886  func NewPopulatedMapTest(r randyMap, easy bool) *MapTest {
   887  	this := &MapTest{}
   888  	if r.Intn(5) != 0 {
   889  		v1 := r.Intn(10)
   890  		this.StrStr = make(map[string]string)
   891  		for i := 0; i < v1; i++ {
   892  			this.StrStr[randStringMap(r)] = randStringMap(r)
   893  		}
   894  	}
   895  	if !easy && r.Intn(10) != 0 {
   896  		this.XXX_unrecognized = randUnrecognizedMap(r, 2)
   897  	}
   898  	return this
   899  }
   900  
   901  func NewPopulatedFakeMap(r randyMap, easy bool) *FakeMap {
   902  	this := &FakeMap{}
   903  	if r.Intn(5) != 0 {
   904  		v2 := r.Intn(5)
   905  		this.Entries = make([]*FakeMapEntry, v2)
   906  		for i := 0; i < v2; i++ {
   907  			this.Entries[i] = NewPopulatedFakeMapEntry(r, easy)
   908  		}
   909  	}
   910  	if !easy && r.Intn(10) != 0 {
   911  		this.XXX_unrecognized = randUnrecognizedMap(r, 2)
   912  	}
   913  	return this
   914  }
   915  
   916  func NewPopulatedFakeMapEntry(r randyMap, easy bool) *FakeMapEntry {
   917  	this := &FakeMapEntry{}
   918  	this.Key = string(randStringMap(r))
   919  	this.Value = string(randStringMap(r))
   920  	this.Other = string(randStringMap(r))
   921  	if !easy && r.Intn(10) != 0 {
   922  		this.XXX_unrecognized = randUnrecognizedMap(r, 4)
   923  	}
   924  	return this
   925  }
   926  
   927  type randyMap interface {
   928  	Float32() float32
   929  	Float64() float64
   930  	Int63() int64
   931  	Int31() int32
   932  	Uint32() uint32
   933  	Intn(n int) int
   934  }
   935  
   936  func randUTF8RuneMap(r randyMap) rune {
   937  	ru := r.Intn(62)
   938  	if ru < 10 {
   939  		return rune(ru + 48)
   940  	} else if ru < 36 {
   941  		return rune(ru + 55)
   942  	}
   943  	return rune(ru + 61)
   944  }
   945  func randStringMap(r randyMap) string {
   946  	v3 := r.Intn(100)
   947  	tmps := make([]rune, v3)
   948  	for i := 0; i < v3; i++ {
   949  		tmps[i] = randUTF8RuneMap(r)
   950  	}
   951  	return string(tmps)
   952  }
   953  func randUnrecognizedMap(r randyMap, maxFieldNumber int) (dAtA []byte) {
   954  	l := r.Intn(5)
   955  	for i := 0; i < l; i++ {
   956  		wire := r.Intn(4)
   957  		if wire == 3 {
   958  			wire = 5
   959  		}
   960  		fieldNumber := maxFieldNumber + r.Intn(100)
   961  		dAtA = randFieldMap(dAtA, r, fieldNumber, wire)
   962  	}
   963  	return dAtA
   964  }
   965  func randFieldMap(dAtA []byte, r randyMap, fieldNumber int, wire int) []byte {
   966  	key := uint32(fieldNumber)<<3 | uint32(wire)
   967  	switch wire {
   968  	case 0:
   969  		dAtA = encodeVarintPopulateMap(dAtA, uint64(key))
   970  		v4 := r.Int63()
   971  		if r.Intn(2) == 0 {
   972  			v4 *= -1
   973  		}
   974  		dAtA = encodeVarintPopulateMap(dAtA, uint64(v4))
   975  	case 1:
   976  		dAtA = encodeVarintPopulateMap(dAtA, uint64(key))
   977  		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)))
   978  	case 2:
   979  		dAtA = encodeVarintPopulateMap(dAtA, uint64(key))
   980  		ll := r.Intn(100)
   981  		dAtA = encodeVarintPopulateMap(dAtA, uint64(ll))
   982  		for j := 0; j < ll; j++ {
   983  			dAtA = append(dAtA, byte(r.Intn(256)))
   984  		}
   985  	default:
   986  		dAtA = encodeVarintPopulateMap(dAtA, uint64(key))
   987  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
   988  	}
   989  	return dAtA
   990  }
   991  func encodeVarintPopulateMap(dAtA []byte, v uint64) []byte {
   992  	for v >= 1<<7 {
   993  		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
   994  		v >>= 7
   995  	}
   996  	dAtA = append(dAtA, uint8(v))
   997  	return dAtA
   998  }
   999  func (m *MapTest) Size() (n int) {
  1000  	if m == nil {
  1001  		return 0
  1002  	}
  1003  	var l int
  1004  	_ = l
  1005  	if len(m.StrStr) > 0 {
  1006  		for k, v := range m.StrStr {
  1007  			_ = k
  1008  			_ = v
  1009  			mapEntrySize := 1 + len(k) + sovMap(uint64(len(k))) + 1 + len(v) + sovMap(uint64(len(v)))
  1010  			n += mapEntrySize + 1 + sovMap(uint64(mapEntrySize))
  1011  		}
  1012  	}
  1013  	if m.XXX_unrecognized != nil {
  1014  		n += len(m.XXX_unrecognized)
  1015  	}
  1016  	return n
  1017  }
  1018  
  1019  func (m *FakeMap) Size() (n int) {
  1020  	if m == nil {
  1021  		return 0
  1022  	}
  1023  	var l int
  1024  	_ = l
  1025  	if len(m.Entries) > 0 {
  1026  		for _, e := range m.Entries {
  1027  			l = e.Size()
  1028  			n += 1 + l + sovMap(uint64(l))
  1029  		}
  1030  	}
  1031  	if m.XXX_unrecognized != nil {
  1032  		n += len(m.XXX_unrecognized)
  1033  	}
  1034  	return n
  1035  }
  1036  
  1037  func (m *FakeMapEntry) Size() (n int) {
  1038  	if m == nil {
  1039  		return 0
  1040  	}
  1041  	var l int
  1042  	_ = l
  1043  	l = len(m.Key)
  1044  	if l > 0 {
  1045  		n += 1 + l + sovMap(uint64(l))
  1046  	}
  1047  	l = len(m.Value)
  1048  	if l > 0 {
  1049  		n += 1 + l + sovMap(uint64(l))
  1050  	}
  1051  	l = len(m.Other)
  1052  	if l > 0 {
  1053  		n += 1 + l + sovMap(uint64(l))
  1054  	}
  1055  	if m.XXX_unrecognized != nil {
  1056  		n += len(m.XXX_unrecognized)
  1057  	}
  1058  	return n
  1059  }
  1060  
  1061  func sovMap(x uint64) (n int) {
  1062  	return (math_bits.Len64(x|1) + 6) / 7
  1063  }
  1064  func sozMap(x uint64) (n int) {
  1065  	return sovMap(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1066  }
  1067  func (this *MapTest) String() string {
  1068  	if this == nil {
  1069  		return "nil"
  1070  	}
  1071  	keysForStrStr := make([]string, 0, len(this.StrStr))
  1072  	for k := range this.StrStr {
  1073  		keysForStrStr = append(keysForStrStr, k)
  1074  	}
  1075  	github_com_gogo_protobuf_sortkeys.Strings(keysForStrStr)
  1076  	mapStringForStrStr := "map[string]string{"
  1077  	for _, k := range keysForStrStr {
  1078  		mapStringForStrStr += fmt.Sprintf("%v: %v,", k, this.StrStr[k])
  1079  	}
  1080  	mapStringForStrStr += "}"
  1081  	s := strings.Join([]string{`&MapTest{`,
  1082  		`StrStr:` + mapStringForStrStr + `,`,
  1083  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1084  		`}`,
  1085  	}, "")
  1086  	return s
  1087  }
  1088  func (this *FakeMap) String() string {
  1089  	if this == nil {
  1090  		return "nil"
  1091  	}
  1092  	repeatedStringForEntries := "[]*FakeMapEntry{"
  1093  	for _, f := range this.Entries {
  1094  		repeatedStringForEntries += strings.Replace(f.String(), "FakeMapEntry", "FakeMapEntry", 1) + ","
  1095  	}
  1096  	repeatedStringForEntries += "}"
  1097  	s := strings.Join([]string{`&FakeMap{`,
  1098  		`Entries:` + repeatedStringForEntries + `,`,
  1099  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1100  		`}`,
  1101  	}, "")
  1102  	return s
  1103  }
  1104  func (this *FakeMapEntry) String() string {
  1105  	if this == nil {
  1106  		return "nil"
  1107  	}
  1108  	s := strings.Join([]string{`&FakeMapEntry{`,
  1109  		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
  1110  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1111  		`Other:` + fmt.Sprintf("%v", this.Other) + `,`,
  1112  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1113  		`}`,
  1114  	}, "")
  1115  	return s
  1116  }
  1117  func valueToStringMap(v interface{}) string {
  1118  	rv := reflect.ValueOf(v)
  1119  	if rv.IsNil() {
  1120  		return "nil"
  1121  	}
  1122  	pv := reflect.Indirect(rv).Interface()
  1123  	return fmt.Sprintf("*%v", pv)
  1124  }
  1125  func (m *MapTest) Unmarshal(dAtA []byte) error {
  1126  	l := len(dAtA)
  1127  	iNdEx := 0
  1128  	for iNdEx < l {
  1129  		preIndex := iNdEx
  1130  		var wire uint64
  1131  		for shift := uint(0); ; shift += 7 {
  1132  			if shift >= 64 {
  1133  				return ErrIntOverflowMap
  1134  			}
  1135  			if iNdEx >= l {
  1136  				return io.ErrUnexpectedEOF
  1137  			}
  1138  			b := dAtA[iNdEx]
  1139  			iNdEx++
  1140  			wire |= uint64(b&0x7F) << shift
  1141  			if b < 0x80 {
  1142  				break
  1143  			}
  1144  		}
  1145  		fieldNum := int32(wire >> 3)
  1146  		wireType := int(wire & 0x7)
  1147  		if wireType == 4 {
  1148  			return fmt.Errorf("proto: MapTest: wiretype end group for non-group")
  1149  		}
  1150  		if fieldNum <= 0 {
  1151  			return fmt.Errorf("proto: MapTest: illegal tag %d (wire type %d)", fieldNum, wire)
  1152  		}
  1153  		switch fieldNum {
  1154  		case 1:
  1155  			if wireType != 2 {
  1156  				return fmt.Errorf("proto: wrong wireType = %d for field StrStr", wireType)
  1157  			}
  1158  			var msglen int
  1159  			for shift := uint(0); ; shift += 7 {
  1160  				if shift >= 64 {
  1161  					return ErrIntOverflowMap
  1162  				}
  1163  				if iNdEx >= l {
  1164  					return io.ErrUnexpectedEOF
  1165  				}
  1166  				b := dAtA[iNdEx]
  1167  				iNdEx++
  1168  				msglen |= int(b&0x7F) << shift
  1169  				if b < 0x80 {
  1170  					break
  1171  				}
  1172  			}
  1173  			if msglen < 0 {
  1174  				return ErrInvalidLengthMap
  1175  			}
  1176  			postIndex := iNdEx + msglen
  1177  			if postIndex < 0 {
  1178  				return ErrInvalidLengthMap
  1179  			}
  1180  			if postIndex > l {
  1181  				return io.ErrUnexpectedEOF
  1182  			}
  1183  			if m.StrStr == nil {
  1184  				m.StrStr = make(map[string]string)
  1185  			}
  1186  			var mapkey string
  1187  			var mapvalue string
  1188  			for iNdEx < postIndex {
  1189  				entryPreIndex := iNdEx
  1190  				var wire uint64
  1191  				for shift := uint(0); ; shift += 7 {
  1192  					if shift >= 64 {
  1193  						return ErrIntOverflowMap
  1194  					}
  1195  					if iNdEx >= l {
  1196  						return io.ErrUnexpectedEOF
  1197  					}
  1198  					b := dAtA[iNdEx]
  1199  					iNdEx++
  1200  					wire |= uint64(b&0x7F) << shift
  1201  					if b < 0x80 {
  1202  						break
  1203  					}
  1204  				}
  1205  				fieldNum := int32(wire >> 3)
  1206  				if fieldNum == 1 {
  1207  					var stringLenmapkey uint64
  1208  					for shift := uint(0); ; shift += 7 {
  1209  						if shift >= 64 {
  1210  							return ErrIntOverflowMap
  1211  						}
  1212  						if iNdEx >= l {
  1213  							return io.ErrUnexpectedEOF
  1214  						}
  1215  						b := dAtA[iNdEx]
  1216  						iNdEx++
  1217  						stringLenmapkey |= uint64(b&0x7F) << shift
  1218  						if b < 0x80 {
  1219  							break
  1220  						}
  1221  					}
  1222  					intStringLenmapkey := int(stringLenmapkey)
  1223  					if intStringLenmapkey < 0 {
  1224  						return ErrInvalidLengthMap
  1225  					}
  1226  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  1227  					if postStringIndexmapkey < 0 {
  1228  						return ErrInvalidLengthMap
  1229  					}
  1230  					if postStringIndexmapkey > l {
  1231  						return io.ErrUnexpectedEOF
  1232  					}
  1233  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  1234  					iNdEx = postStringIndexmapkey
  1235  				} else if fieldNum == 2 {
  1236  					var stringLenmapvalue uint64
  1237  					for shift := uint(0); ; shift += 7 {
  1238  						if shift >= 64 {
  1239  							return ErrIntOverflowMap
  1240  						}
  1241  						if iNdEx >= l {
  1242  							return io.ErrUnexpectedEOF
  1243  						}
  1244  						b := dAtA[iNdEx]
  1245  						iNdEx++
  1246  						stringLenmapvalue |= uint64(b&0x7F) << shift
  1247  						if b < 0x80 {
  1248  							break
  1249  						}
  1250  					}
  1251  					intStringLenmapvalue := int(stringLenmapvalue)
  1252  					if intStringLenmapvalue < 0 {
  1253  						return ErrInvalidLengthMap
  1254  					}
  1255  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  1256  					if postStringIndexmapvalue < 0 {
  1257  						return ErrInvalidLengthMap
  1258  					}
  1259  					if postStringIndexmapvalue > l {
  1260  						return io.ErrUnexpectedEOF
  1261  					}
  1262  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  1263  					iNdEx = postStringIndexmapvalue
  1264  				} else {
  1265  					iNdEx = entryPreIndex
  1266  					skippy, err := skipMap(dAtA[iNdEx:])
  1267  					if err != nil {
  1268  						return err
  1269  					}
  1270  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  1271  						return ErrInvalidLengthMap
  1272  					}
  1273  					if (iNdEx + skippy) > postIndex {
  1274  						return io.ErrUnexpectedEOF
  1275  					}
  1276  					iNdEx += skippy
  1277  				}
  1278  			}
  1279  			m.StrStr[mapkey] = mapvalue
  1280  			iNdEx = postIndex
  1281  		default:
  1282  			iNdEx = preIndex
  1283  			skippy, err := skipMap(dAtA[iNdEx:])
  1284  			if err != nil {
  1285  				return err
  1286  			}
  1287  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1288  				return ErrInvalidLengthMap
  1289  			}
  1290  			if (iNdEx + skippy) > l {
  1291  				return io.ErrUnexpectedEOF
  1292  			}
  1293  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1294  			iNdEx += skippy
  1295  		}
  1296  	}
  1297  
  1298  	if iNdEx > l {
  1299  		return io.ErrUnexpectedEOF
  1300  	}
  1301  	return nil
  1302  }
  1303  func (m *FakeMap) Unmarshal(dAtA []byte) error {
  1304  	l := len(dAtA)
  1305  	iNdEx := 0
  1306  	for iNdEx < l {
  1307  		preIndex := iNdEx
  1308  		var wire uint64
  1309  		for shift := uint(0); ; shift += 7 {
  1310  			if shift >= 64 {
  1311  				return ErrIntOverflowMap
  1312  			}
  1313  			if iNdEx >= l {
  1314  				return io.ErrUnexpectedEOF
  1315  			}
  1316  			b := dAtA[iNdEx]
  1317  			iNdEx++
  1318  			wire |= uint64(b&0x7F) << shift
  1319  			if b < 0x80 {
  1320  				break
  1321  			}
  1322  		}
  1323  		fieldNum := int32(wire >> 3)
  1324  		wireType := int(wire & 0x7)
  1325  		if wireType == 4 {
  1326  			return fmt.Errorf("proto: FakeMap: wiretype end group for non-group")
  1327  		}
  1328  		if fieldNum <= 0 {
  1329  			return fmt.Errorf("proto: FakeMap: illegal tag %d (wire type %d)", fieldNum, wire)
  1330  		}
  1331  		switch fieldNum {
  1332  		case 1:
  1333  			if wireType != 2 {
  1334  				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
  1335  			}
  1336  			var msglen int
  1337  			for shift := uint(0); ; shift += 7 {
  1338  				if shift >= 64 {
  1339  					return ErrIntOverflowMap
  1340  				}
  1341  				if iNdEx >= l {
  1342  					return io.ErrUnexpectedEOF
  1343  				}
  1344  				b := dAtA[iNdEx]
  1345  				iNdEx++
  1346  				msglen |= int(b&0x7F) << shift
  1347  				if b < 0x80 {
  1348  					break
  1349  				}
  1350  			}
  1351  			if msglen < 0 {
  1352  				return ErrInvalidLengthMap
  1353  			}
  1354  			postIndex := iNdEx + msglen
  1355  			if postIndex < 0 {
  1356  				return ErrInvalidLengthMap
  1357  			}
  1358  			if postIndex > l {
  1359  				return io.ErrUnexpectedEOF
  1360  			}
  1361  			m.Entries = append(m.Entries, &FakeMapEntry{})
  1362  			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1363  				return err
  1364  			}
  1365  			iNdEx = postIndex
  1366  		default:
  1367  			iNdEx = preIndex
  1368  			skippy, err := skipMap(dAtA[iNdEx:])
  1369  			if err != nil {
  1370  				return err
  1371  			}
  1372  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1373  				return ErrInvalidLengthMap
  1374  			}
  1375  			if (iNdEx + skippy) > l {
  1376  				return io.ErrUnexpectedEOF
  1377  			}
  1378  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1379  			iNdEx += skippy
  1380  		}
  1381  	}
  1382  
  1383  	if iNdEx > l {
  1384  		return io.ErrUnexpectedEOF
  1385  	}
  1386  	return nil
  1387  }
  1388  func (m *FakeMapEntry) Unmarshal(dAtA []byte) error {
  1389  	l := len(dAtA)
  1390  	iNdEx := 0
  1391  	for iNdEx < l {
  1392  		preIndex := iNdEx
  1393  		var wire uint64
  1394  		for shift := uint(0); ; shift += 7 {
  1395  			if shift >= 64 {
  1396  				return ErrIntOverflowMap
  1397  			}
  1398  			if iNdEx >= l {
  1399  				return io.ErrUnexpectedEOF
  1400  			}
  1401  			b := dAtA[iNdEx]
  1402  			iNdEx++
  1403  			wire |= uint64(b&0x7F) << shift
  1404  			if b < 0x80 {
  1405  				break
  1406  			}
  1407  		}
  1408  		fieldNum := int32(wire >> 3)
  1409  		wireType := int(wire & 0x7)
  1410  		if wireType == 4 {
  1411  			return fmt.Errorf("proto: FakeMapEntry: wiretype end group for non-group")
  1412  		}
  1413  		if fieldNum <= 0 {
  1414  			return fmt.Errorf("proto: FakeMapEntry: illegal tag %d (wire type %d)", fieldNum, wire)
  1415  		}
  1416  		switch fieldNum {
  1417  		case 1:
  1418  			if wireType != 2 {
  1419  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  1420  			}
  1421  			var stringLen uint64
  1422  			for shift := uint(0); ; shift += 7 {
  1423  				if shift >= 64 {
  1424  					return ErrIntOverflowMap
  1425  				}
  1426  				if iNdEx >= l {
  1427  					return io.ErrUnexpectedEOF
  1428  				}
  1429  				b := dAtA[iNdEx]
  1430  				iNdEx++
  1431  				stringLen |= uint64(b&0x7F) << shift
  1432  				if b < 0x80 {
  1433  					break
  1434  				}
  1435  			}
  1436  			intStringLen := int(stringLen)
  1437  			if intStringLen < 0 {
  1438  				return ErrInvalidLengthMap
  1439  			}
  1440  			postIndex := iNdEx + intStringLen
  1441  			if postIndex < 0 {
  1442  				return ErrInvalidLengthMap
  1443  			}
  1444  			if postIndex > l {
  1445  				return io.ErrUnexpectedEOF
  1446  			}
  1447  			m.Key = string(dAtA[iNdEx:postIndex])
  1448  			iNdEx = postIndex
  1449  		case 2:
  1450  			if wireType != 2 {
  1451  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  1452  			}
  1453  			var stringLen uint64
  1454  			for shift := uint(0); ; shift += 7 {
  1455  				if shift >= 64 {
  1456  					return ErrIntOverflowMap
  1457  				}
  1458  				if iNdEx >= l {
  1459  					return io.ErrUnexpectedEOF
  1460  				}
  1461  				b := dAtA[iNdEx]
  1462  				iNdEx++
  1463  				stringLen |= uint64(b&0x7F) << shift
  1464  				if b < 0x80 {
  1465  					break
  1466  				}
  1467  			}
  1468  			intStringLen := int(stringLen)
  1469  			if intStringLen < 0 {
  1470  				return ErrInvalidLengthMap
  1471  			}
  1472  			postIndex := iNdEx + intStringLen
  1473  			if postIndex < 0 {
  1474  				return ErrInvalidLengthMap
  1475  			}
  1476  			if postIndex > l {
  1477  				return io.ErrUnexpectedEOF
  1478  			}
  1479  			m.Value = string(dAtA[iNdEx:postIndex])
  1480  			iNdEx = postIndex
  1481  		case 3:
  1482  			if wireType != 2 {
  1483  				return fmt.Errorf("proto: wrong wireType = %d for field Other", wireType)
  1484  			}
  1485  			var stringLen uint64
  1486  			for shift := uint(0); ; shift += 7 {
  1487  				if shift >= 64 {
  1488  					return ErrIntOverflowMap
  1489  				}
  1490  				if iNdEx >= l {
  1491  					return io.ErrUnexpectedEOF
  1492  				}
  1493  				b := dAtA[iNdEx]
  1494  				iNdEx++
  1495  				stringLen |= uint64(b&0x7F) << shift
  1496  				if b < 0x80 {
  1497  					break
  1498  				}
  1499  			}
  1500  			intStringLen := int(stringLen)
  1501  			if intStringLen < 0 {
  1502  				return ErrInvalidLengthMap
  1503  			}
  1504  			postIndex := iNdEx + intStringLen
  1505  			if postIndex < 0 {
  1506  				return ErrInvalidLengthMap
  1507  			}
  1508  			if postIndex > l {
  1509  				return io.ErrUnexpectedEOF
  1510  			}
  1511  			m.Other = string(dAtA[iNdEx:postIndex])
  1512  			iNdEx = postIndex
  1513  		default:
  1514  			iNdEx = preIndex
  1515  			skippy, err := skipMap(dAtA[iNdEx:])
  1516  			if err != nil {
  1517  				return err
  1518  			}
  1519  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1520  				return ErrInvalidLengthMap
  1521  			}
  1522  			if (iNdEx + skippy) > l {
  1523  				return io.ErrUnexpectedEOF
  1524  			}
  1525  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1526  			iNdEx += skippy
  1527  		}
  1528  	}
  1529  
  1530  	if iNdEx > l {
  1531  		return io.ErrUnexpectedEOF
  1532  	}
  1533  	return nil
  1534  }
  1535  func skipMap(dAtA []byte) (n int, err error) {
  1536  	l := len(dAtA)
  1537  	iNdEx := 0
  1538  	depth := 0
  1539  	for iNdEx < l {
  1540  		var wire uint64
  1541  		for shift := uint(0); ; shift += 7 {
  1542  			if shift >= 64 {
  1543  				return 0, ErrIntOverflowMap
  1544  			}
  1545  			if iNdEx >= l {
  1546  				return 0, io.ErrUnexpectedEOF
  1547  			}
  1548  			b := dAtA[iNdEx]
  1549  			iNdEx++
  1550  			wire |= (uint64(b) & 0x7F) << shift
  1551  			if b < 0x80 {
  1552  				break
  1553  			}
  1554  		}
  1555  		wireType := int(wire & 0x7)
  1556  		switch wireType {
  1557  		case 0:
  1558  			for shift := uint(0); ; shift += 7 {
  1559  				if shift >= 64 {
  1560  					return 0, ErrIntOverflowMap
  1561  				}
  1562  				if iNdEx >= l {
  1563  					return 0, io.ErrUnexpectedEOF
  1564  				}
  1565  				iNdEx++
  1566  				if dAtA[iNdEx-1] < 0x80 {
  1567  					break
  1568  				}
  1569  			}
  1570  		case 1:
  1571  			iNdEx += 8
  1572  		case 2:
  1573  			var length int
  1574  			for shift := uint(0); ; shift += 7 {
  1575  				if shift >= 64 {
  1576  					return 0, ErrIntOverflowMap
  1577  				}
  1578  				if iNdEx >= l {
  1579  					return 0, io.ErrUnexpectedEOF
  1580  				}
  1581  				b := dAtA[iNdEx]
  1582  				iNdEx++
  1583  				length |= (int(b) & 0x7F) << shift
  1584  				if b < 0x80 {
  1585  					break
  1586  				}
  1587  			}
  1588  			if length < 0 {
  1589  				return 0, ErrInvalidLengthMap
  1590  			}
  1591  			iNdEx += length
  1592  		case 3:
  1593  			depth++
  1594  		case 4:
  1595  			if depth == 0 {
  1596  				return 0, ErrUnexpectedEndOfGroupMap
  1597  			}
  1598  			depth--
  1599  		case 5:
  1600  			iNdEx += 4
  1601  		default:
  1602  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1603  		}
  1604  		if iNdEx < 0 {
  1605  			return 0, ErrInvalidLengthMap
  1606  		}
  1607  		if depth == 0 {
  1608  			return iNdEx, nil
  1609  		}
  1610  	}
  1611  	return 0, io.ErrUnexpectedEOF
  1612  }
  1613  
  1614  var (
  1615  	ErrInvalidLengthMap        = fmt.Errorf("proto: negative length found during unmarshaling")
  1616  	ErrIntOverflowMap          = fmt.Errorf("proto: integer overflow")
  1617  	ErrUnexpectedEndOfGroupMap = fmt.Errorf("proto: unexpected end of group")
  1618  )
  1619  

View as plain text