Source file src/github.com/gogo/protobuf/test/issue530/issue530.pb.go

Documentation: github.com/gogo/protobuf/test/issue530

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: issue530.proto
     3  
     4  package issue530
     5  
     6  import (
     7  	fmt "fmt"
     8  	_ "github.com/gogo/protobuf/gogoproto"
     9  	proto "github.com/gogo/protobuf/proto"
    10  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    11  	io "io"
    12  	math "math"
    13  	math_bits "math/bits"
    14  	reflect "reflect"
    15  	strings "strings"
    16  )
    17  
    18  // Reference imports to suppress errors if they are not otherwise used.
    19  var _ = proto.Marshal
    20  var _ = fmt.Errorf
    21  var _ = math.Inf
    22  
    23  // This is a compile-time assertion to ensure that this generated file
    24  // is compatible with the proto package it is being compiled against.
    25  // A compilation error at this line likely means your copy of the
    26  // proto package needs to be updated.
    27  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    28  
    29  type Foo5 struct {
    30  	Bar1    Bar1             `protobuf:"bytes,1,opt,name=bar1" json:"bar1"`
    31  	Bar2    *Bar1            `protobuf:"bytes,2,opt,name=bar2" json:"bar2,omitempty"`
    32  	Bar3    Bar2             `protobuf:"bytes,3,opt,name=bar3" json:"bar3"`
    33  	Bar4    *Bar2            `protobuf:"bytes,4,opt,name=bar4" json:"bar4,omitempty"`
    34  	Bars1   []Bar1           `protobuf:"bytes,5,rep,name=bars1" json:"bars1"`
    35  	Bars2   []*Bar1          `protobuf:"bytes,6,rep,name=bars2" json:"bars2,omitempty"`
    36  	Bars3   []Bar2           `protobuf:"bytes,7,rep,name=bars3" json:"bars3"`
    37  	Bars4   []*Bar2          `protobuf:"bytes,8,rep,name=bars4" json:"bars4,omitempty"`
    38  	Barrs1  []Bar3           `protobuf:"bytes,9,rep,name=barrs1" json:"barrs1"`
    39  	Barrs2  []Bar5           `protobuf:"bytes,10,rep,name=barrs2" json:"barrs2"`
    40  	Barmap1 map[string]*Bar3 `protobuf:"bytes,11,rep,name=barmap1" json:"barmap1,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
    41  	Barmap2 map[string]*Bar5 `protobuf:"bytes,12,rep,name=barmap2" json:"barmap2,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
    42  }
    43  
    44  func (m *Foo5) Reset()      { *m = Foo5{} }
    45  func (*Foo5) ProtoMessage() {}
    46  func (*Foo5) Descriptor() ([]byte, []int) {
    47  	return fileDescriptor_c2447996d16f3907, []int{0}
    48  }
    49  func (m *Foo5) XXX_Unmarshal(b []byte) error {
    50  	return m.Unmarshal(b)
    51  }
    52  func (m *Foo5) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    53  	if deterministic {
    54  		return xxx_messageInfo_Foo5.Marshal(b, m, deterministic)
    55  	} else {
    56  		b = b[:cap(b)]
    57  		n, err := m.MarshalToSizedBuffer(b)
    58  		if err != nil {
    59  			return nil, err
    60  		}
    61  		return b[:n], nil
    62  	}
    63  }
    64  func (m *Foo5) XXX_Merge(src proto.Message) {
    65  	xxx_messageInfo_Foo5.Merge(m, src)
    66  }
    67  func (m *Foo5) XXX_Size() int {
    68  	return m.Size()
    69  }
    70  func (m *Foo5) XXX_DiscardUnknown() {
    71  	xxx_messageInfo_Foo5.DiscardUnknown(m)
    72  }
    73  
    74  var xxx_messageInfo_Foo5 proto.InternalMessageInfo
    75  
    76  func (m *Foo5) GetBar1() Bar1 {
    77  	if m != nil {
    78  		return m.Bar1
    79  	}
    80  	return Bar1{}
    81  }
    82  
    83  func (m *Foo5) GetBar2() *Bar1 {
    84  	if m != nil {
    85  		return m.Bar2
    86  	}
    87  	return nil
    88  }
    89  
    90  func (m *Foo5) GetBar3() Bar2 {
    91  	if m != nil {
    92  		return m.Bar3
    93  	}
    94  	return Bar2{}
    95  }
    96  
    97  func (m *Foo5) GetBar4() *Bar2 {
    98  	if m != nil {
    99  		return m.Bar4
   100  	}
   101  	return nil
   102  }
   103  
   104  func (m *Foo5) GetBars1() []Bar1 {
   105  	if m != nil {
   106  		return m.Bars1
   107  	}
   108  	return nil
   109  }
   110  
   111  func (m *Foo5) GetBars2() []*Bar1 {
   112  	if m != nil {
   113  		return m.Bars2
   114  	}
   115  	return nil
   116  }
   117  
   118  func (m *Foo5) GetBars3() []Bar2 {
   119  	if m != nil {
   120  		return m.Bars3
   121  	}
   122  	return nil
   123  }
   124  
   125  func (m *Foo5) GetBars4() []*Bar2 {
   126  	if m != nil {
   127  		return m.Bars4
   128  	}
   129  	return nil
   130  }
   131  
   132  func (m *Foo5) GetBarrs1() []Bar3 {
   133  	if m != nil {
   134  		return m.Barrs1
   135  	}
   136  	return nil
   137  }
   138  
   139  func (m *Foo5) GetBarrs2() []Bar5 {
   140  	if m != nil {
   141  		return m.Barrs2
   142  	}
   143  	return nil
   144  }
   145  
   146  func (m *Foo5) GetBarmap1() map[string]*Bar3 {
   147  	if m != nil {
   148  		return m.Barmap1
   149  	}
   150  	return nil
   151  }
   152  
   153  func (m *Foo5) GetBarmap2() map[string]*Bar5 {
   154  	if m != nil {
   155  		return m.Barmap2
   156  	}
   157  	return nil
   158  }
   159  
   160  type Bar1 struct {
   161  	Str string `protobuf:"bytes,1,opt,name=str" json:"str"`
   162  }
   163  
   164  func (m *Bar1) Reset()      { *m = Bar1{} }
   165  func (*Bar1) ProtoMessage() {}
   166  func (*Bar1) Descriptor() ([]byte, []int) {
   167  	return fileDescriptor_c2447996d16f3907, []int{1}
   168  }
   169  func (m *Bar1) XXX_Unmarshal(b []byte) error {
   170  	return m.Unmarshal(b)
   171  }
   172  func (m *Bar1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   173  	if deterministic {
   174  		return xxx_messageInfo_Bar1.Marshal(b, m, deterministic)
   175  	} else {
   176  		b = b[:cap(b)]
   177  		n, err := m.MarshalToSizedBuffer(b)
   178  		if err != nil {
   179  			return nil, err
   180  		}
   181  		return b[:n], nil
   182  	}
   183  }
   184  func (m *Bar1) XXX_Merge(src proto.Message) {
   185  	xxx_messageInfo_Bar1.Merge(m, src)
   186  }
   187  func (m *Bar1) XXX_Size() int {
   188  	return m.Size()
   189  }
   190  func (m *Bar1) XXX_DiscardUnknown() {
   191  	xxx_messageInfo_Bar1.DiscardUnknown(m)
   192  }
   193  
   194  var xxx_messageInfo_Bar1 proto.InternalMessageInfo
   195  
   196  func (m *Bar1) GetStr() string {
   197  	if m != nil {
   198  		return m.Str
   199  	}
   200  	return ""
   201  }
   202  
   203  type Bar2 struct {
   204  	Str *string `protobuf:"bytes,1,opt,name=str" json:"str,omitempty"`
   205  }
   206  
   207  func (m *Bar2) Reset()      { *m = Bar2{} }
   208  func (*Bar2) ProtoMessage() {}
   209  func (*Bar2) Descriptor() ([]byte, []int) {
   210  	return fileDescriptor_c2447996d16f3907, []int{2}
   211  }
   212  func (m *Bar2) XXX_Unmarshal(b []byte) error {
   213  	return m.Unmarshal(b)
   214  }
   215  func (m *Bar2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   216  	if deterministic {
   217  		return xxx_messageInfo_Bar2.Marshal(b, m, deterministic)
   218  	} else {
   219  		b = b[:cap(b)]
   220  		n, err := m.MarshalToSizedBuffer(b)
   221  		if err != nil {
   222  			return nil, err
   223  		}
   224  		return b[:n], nil
   225  	}
   226  }
   227  func (m *Bar2) XXX_Merge(src proto.Message) {
   228  	xxx_messageInfo_Bar2.Merge(m, src)
   229  }
   230  func (m *Bar2) XXX_Size() int {
   231  	return m.Size()
   232  }
   233  func (m *Bar2) XXX_DiscardUnknown() {
   234  	xxx_messageInfo_Bar2.DiscardUnknown(m)
   235  }
   236  
   237  var xxx_messageInfo_Bar2 proto.InternalMessageInfo
   238  
   239  func (m *Bar2) GetStr() string {
   240  	if m != nil && m.Str != nil {
   241  		return *m.Str
   242  	}
   243  	return ""
   244  }
   245  
   246  type Bar3 struct {
   247  	Bars4 []Bar4 `protobuf:"bytes,1,rep,name=bars4" json:"bars4"`
   248  	Bars2 []Bar2 `protobuf:"bytes,2,rep,name=bars2" json:"bars2"`
   249  }
   250  
   251  func (m *Bar3) Reset()      { *m = Bar3{} }
   252  func (*Bar3) ProtoMessage() {}
   253  func (*Bar3) Descriptor() ([]byte, []int) {
   254  	return fileDescriptor_c2447996d16f3907, []int{3}
   255  }
   256  func (m *Bar3) XXX_Unmarshal(b []byte) error {
   257  	return m.Unmarshal(b)
   258  }
   259  func (m *Bar3) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   260  	if deterministic {
   261  		return xxx_messageInfo_Bar3.Marshal(b, m, deterministic)
   262  	} else {
   263  		b = b[:cap(b)]
   264  		n, err := m.MarshalToSizedBuffer(b)
   265  		if err != nil {
   266  			return nil, err
   267  		}
   268  		return b[:n], nil
   269  	}
   270  }
   271  func (m *Bar3) XXX_Merge(src proto.Message) {
   272  	xxx_messageInfo_Bar3.Merge(m, src)
   273  }
   274  func (m *Bar3) XXX_Size() int {
   275  	return m.Size()
   276  }
   277  func (m *Bar3) XXX_DiscardUnknown() {
   278  	xxx_messageInfo_Bar3.DiscardUnknown(m)
   279  }
   280  
   281  var xxx_messageInfo_Bar3 proto.InternalMessageInfo
   282  
   283  func (m *Bar3) GetBars4() []Bar4 {
   284  	if m != nil {
   285  		return m.Bars4
   286  	}
   287  	return nil
   288  }
   289  
   290  func (m *Bar3) GetBars2() []Bar2 {
   291  	if m != nil {
   292  		return m.Bars2
   293  	}
   294  	return nil
   295  }
   296  
   297  type Bar4 struct {
   298  	Str string `protobuf:"bytes,1,opt,name=str" json:"str"`
   299  }
   300  
   301  func (m *Bar4) Reset()      { *m = Bar4{} }
   302  func (*Bar4) ProtoMessage() {}
   303  func (*Bar4) Descriptor() ([]byte, []int) {
   304  	return fileDescriptor_c2447996d16f3907, []int{4}
   305  }
   306  func (m *Bar4) XXX_Unmarshal(b []byte) error {
   307  	return m.Unmarshal(b)
   308  }
   309  func (m *Bar4) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   310  	if deterministic {
   311  		return xxx_messageInfo_Bar4.Marshal(b, m, deterministic)
   312  	} else {
   313  		b = b[:cap(b)]
   314  		n, err := m.MarshalToSizedBuffer(b)
   315  		if err != nil {
   316  			return nil, err
   317  		}
   318  		return b[:n], nil
   319  	}
   320  }
   321  func (m *Bar4) XXX_Merge(src proto.Message) {
   322  	xxx_messageInfo_Bar4.Merge(m, src)
   323  }
   324  func (m *Bar4) XXX_Size() int {
   325  	return m.Size()
   326  }
   327  func (m *Bar4) XXX_DiscardUnknown() {
   328  	xxx_messageInfo_Bar4.DiscardUnknown(m)
   329  }
   330  
   331  var xxx_messageInfo_Bar4 proto.InternalMessageInfo
   332  
   333  func (m *Bar4) GetStr() string {
   334  	if m != nil {
   335  		return m.Str
   336  	}
   337  	return ""
   338  }
   339  
   340  type Bar5 struct {
   341  	Bars2 []*Bar2 `protobuf:"bytes,1,rep,name=bars2" json:"bars2,omitempty"`
   342  	Bars1 []*Bar1 `protobuf:"bytes,2,rep,name=bars1" json:"bars1,omitempty"`
   343  }
   344  
   345  func (m *Bar5) Reset()      { *m = Bar5{} }
   346  func (*Bar5) ProtoMessage() {}
   347  func (*Bar5) Descriptor() ([]byte, []int) {
   348  	return fileDescriptor_c2447996d16f3907, []int{5}
   349  }
   350  func (m *Bar5) XXX_Unmarshal(b []byte) error {
   351  	return m.Unmarshal(b)
   352  }
   353  func (m *Bar5) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   354  	if deterministic {
   355  		return xxx_messageInfo_Bar5.Marshal(b, m, deterministic)
   356  	} else {
   357  		b = b[:cap(b)]
   358  		n, err := m.MarshalToSizedBuffer(b)
   359  		if err != nil {
   360  			return nil, err
   361  		}
   362  		return b[:n], nil
   363  	}
   364  }
   365  func (m *Bar5) XXX_Merge(src proto.Message) {
   366  	xxx_messageInfo_Bar5.Merge(m, src)
   367  }
   368  func (m *Bar5) XXX_Size() int {
   369  	return m.Size()
   370  }
   371  func (m *Bar5) XXX_DiscardUnknown() {
   372  	xxx_messageInfo_Bar5.DiscardUnknown(m)
   373  }
   374  
   375  var xxx_messageInfo_Bar5 proto.InternalMessageInfo
   376  
   377  func (m *Bar5) GetBars2() []*Bar2 {
   378  	if m != nil {
   379  		return m.Bars2
   380  	}
   381  	return nil
   382  }
   383  
   384  func (m *Bar5) GetBars1() []*Bar1 {
   385  	if m != nil {
   386  		return m.Bars1
   387  	}
   388  	return nil
   389  }
   390  
   391  type Bar7 struct {
   392  	Bars71 []Bar7  `protobuf:"bytes,1,rep,name=bars71" json:"bars71"`
   393  	Bars72 []*Bar7 `protobuf:"bytes,2,rep,name=bars72" json:"bars72,omitempty"`
   394  	Str1   string  `protobuf:"bytes,3,opt,name=str1" json:"str1"`
   395  	Str2   *string `protobuf:"bytes,4,opt,name=str2" json:"str2,omitempty"`
   396  }
   397  
   398  func (m *Bar7) Reset()      { *m = Bar7{} }
   399  func (*Bar7) ProtoMessage() {}
   400  func (*Bar7) Descriptor() ([]byte, []int) {
   401  	return fileDescriptor_c2447996d16f3907, []int{6}
   402  }
   403  func (m *Bar7) XXX_Unmarshal(b []byte) error {
   404  	return m.Unmarshal(b)
   405  }
   406  func (m *Bar7) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   407  	if deterministic {
   408  		return xxx_messageInfo_Bar7.Marshal(b, m, deterministic)
   409  	} else {
   410  		b = b[:cap(b)]
   411  		n, err := m.MarshalToSizedBuffer(b)
   412  		if err != nil {
   413  			return nil, err
   414  		}
   415  		return b[:n], nil
   416  	}
   417  }
   418  func (m *Bar7) XXX_Merge(src proto.Message) {
   419  	xxx_messageInfo_Bar7.Merge(m, src)
   420  }
   421  func (m *Bar7) XXX_Size() int {
   422  	return m.Size()
   423  }
   424  func (m *Bar7) XXX_DiscardUnknown() {
   425  	xxx_messageInfo_Bar7.DiscardUnknown(m)
   426  }
   427  
   428  var xxx_messageInfo_Bar7 proto.InternalMessageInfo
   429  
   430  func (m *Bar7) GetBars71() []Bar7 {
   431  	if m != nil {
   432  		return m.Bars71
   433  	}
   434  	return nil
   435  }
   436  
   437  func (m *Bar7) GetBars72() []*Bar7 {
   438  	if m != nil {
   439  		return m.Bars72
   440  	}
   441  	return nil
   442  }
   443  
   444  func (m *Bar7) GetStr1() string {
   445  	if m != nil {
   446  		return m.Str1
   447  	}
   448  	return ""
   449  }
   450  
   451  func (m *Bar7) GetStr2() string {
   452  	if m != nil && m.Str2 != nil {
   453  		return *m.Str2
   454  	}
   455  	return ""
   456  }
   457  
   458  type Bar8 struct {
   459  	Bars1 []Bar9 `protobuf:"bytes,1,rep,name=bars1" json:"bars1"`
   460  }
   461  
   462  func (m *Bar8) Reset()      { *m = Bar8{} }
   463  func (*Bar8) ProtoMessage() {}
   464  func (*Bar8) Descriptor() ([]byte, []int) {
   465  	return fileDescriptor_c2447996d16f3907, []int{7}
   466  }
   467  func (m *Bar8) XXX_Unmarshal(b []byte) error {
   468  	return m.Unmarshal(b)
   469  }
   470  func (m *Bar8) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   471  	if deterministic {
   472  		return xxx_messageInfo_Bar8.Marshal(b, m, deterministic)
   473  	} else {
   474  		b = b[:cap(b)]
   475  		n, err := m.MarshalToSizedBuffer(b)
   476  		if err != nil {
   477  			return nil, err
   478  		}
   479  		return b[:n], nil
   480  	}
   481  }
   482  func (m *Bar8) XXX_Merge(src proto.Message) {
   483  	xxx_messageInfo_Bar8.Merge(m, src)
   484  }
   485  func (m *Bar8) XXX_Size() int {
   486  	return m.Size()
   487  }
   488  func (m *Bar8) XXX_DiscardUnknown() {
   489  	xxx_messageInfo_Bar8.DiscardUnknown(m)
   490  }
   491  
   492  var xxx_messageInfo_Bar8 proto.InternalMessageInfo
   493  
   494  func (m *Bar8) GetBars1() []Bar9 {
   495  	if m != nil {
   496  		return m.Bars1
   497  	}
   498  	return nil
   499  }
   500  
   501  type Bar9 struct {
   502  	Str string `protobuf:"bytes,1,opt,name=str" json:"str"`
   503  }
   504  
   505  func (m *Bar9) Reset()         { *m = Bar9{} }
   506  func (m *Bar9) String() string { return proto.CompactTextString(m) }
   507  func (*Bar9) ProtoMessage()    {}
   508  func (*Bar9) Descriptor() ([]byte, []int) {
   509  	return fileDescriptor_c2447996d16f3907, []int{8}
   510  }
   511  func (m *Bar9) XXX_Unmarshal(b []byte) error {
   512  	return m.Unmarshal(b)
   513  }
   514  func (m *Bar9) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   515  	if deterministic {
   516  		return xxx_messageInfo_Bar9.Marshal(b, m, deterministic)
   517  	} else {
   518  		b = b[:cap(b)]
   519  		n, err := m.MarshalToSizedBuffer(b)
   520  		if err != nil {
   521  			return nil, err
   522  		}
   523  		return b[:n], nil
   524  	}
   525  }
   526  func (m *Bar9) XXX_Merge(src proto.Message) {
   527  	xxx_messageInfo_Bar9.Merge(m, src)
   528  }
   529  func (m *Bar9) XXX_Size() int {
   530  	return m.Size()
   531  }
   532  func (m *Bar9) XXX_DiscardUnknown() {
   533  	xxx_messageInfo_Bar9.DiscardUnknown(m)
   534  }
   535  
   536  var xxx_messageInfo_Bar9 proto.InternalMessageInfo
   537  
   538  func (m *Bar9) GetStr() string {
   539  	if m != nil {
   540  		return m.Str
   541  	}
   542  	return ""
   543  }
   544  
   545  func init() {
   546  	proto.RegisterType((*Foo5)(nil), "issue530.Foo5")
   547  	proto.RegisterMapType((map[string]*Bar3)(nil), "issue530.Foo5.Barmap1Entry")
   548  	proto.RegisterMapType((map[string]*Bar5)(nil), "issue530.Foo5.Barmap2Entry")
   549  	proto.RegisterType((*Bar1)(nil), "issue530.Bar1")
   550  	proto.RegisterType((*Bar2)(nil), "issue530.Bar2")
   551  	proto.RegisterType((*Bar3)(nil), "issue530.Bar3")
   552  	proto.RegisterType((*Bar4)(nil), "issue530.Bar4")
   553  	proto.RegisterType((*Bar5)(nil), "issue530.Bar5")
   554  	proto.RegisterType((*Bar7)(nil), "issue530.Bar7")
   555  	proto.RegisterType((*Bar8)(nil), "issue530.Bar8")
   556  	proto.RegisterType((*Bar9)(nil), "issue530.Bar9")
   557  }
   558  
   559  func init() { proto.RegisterFile("issue530.proto", fileDescriptor_c2447996d16f3907) }
   560  
   561  var fileDescriptor_c2447996d16f3907 = []byte{
   562  	// 507 bytes of a gzipped FileDescriptorProto
   563  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x31, 0x6f, 0xd3, 0x40,
   564  	0x14, 0xc7, 0xfd, 0x12, 0xa7, 0x4d, 0xaf, 0x55, 0x85, 0x6e, 0x40, 0xa7, 0x22, 0x5d, 0x23, 0x8b,
   565  	0x21, 0x42, 0x25, 0xc5, 0xcf, 0xb6, 0xdc, 0x76, 0x8c, 0x04, 0x03, 0x63, 0x3e, 0x00, 0x92, 0x8d,
   566  	0x42, 0xa8, 0xa0, 0xb8, 0x3a, 0x3b, 0x48, 0xdd, 0xfa, 0x11, 0x98, 0x10, 0x23, 0x23, 0x1f, 0x81,
   567  	0x91, 0xb1, 0x63, 0xc7, 0x0e, 0x08, 0x11, 0xe7, 0x4b, 0x30, 0x22, 0x3f, 0x9f, 0x63, 0x47, 0x9c,
   568  	0x89, 0xd4, 0xed, 0xee, 0xde, 0xef, 0xfd, 0xdf, 0xbb, 0xbb, 0xff, 0x63, 0xfb, 0xe7, 0x69, 0x3a,
   569  	0x9f, 0x06, 0xde, 0xb3, 0xd1, 0xa5, 0x4a, 0xb2, 0x84, 0xf7, 0xab, 0xfd, 0xc1, 0xd3, 0xd9, 0x79,
   570  	0xf6, 0x76, 0x1e, 0x8f, 0x5e, 0x27, 0x17, 0xc7, 0xb3, 0x64, 0x96, 0x1c, 0x13, 0x10, 0xcf, 0xdf,
   571  	0xd0, 0x8e, 0x36, 0xb4, 0x2a, 0x13, 0x9d, 0x1f, 0x3d, 0x66, 0xbf, 0x48, 0x92, 0x80, 0x0f, 0x99,
   572  	0x1d, 0x47, 0xca, 0x15, 0x30, 0x80, 0xe1, 0x2e, 0xee, 0x8f, 0x56, 0x05, 0xc6, 0x91, 0x72, 0xc7,
   573  	0xf6, 0xcd, 0xaf, 0x43, 0x6b, 0x42, 0x84, 0x26, 0x51, 0x74, 0x5a, 0x49, 0x20, 0x12, 0x35, 0xe9,
   574  	0x89, 0xae, 0x81, 0xc4, 0x86, 0xa6, 0xa7, 0x49, 0x5f, 0xd8, 0xad, 0x64, 0xa9, 0xe9, 0xf3, 0x27,
   575  	0xac, 0x17, 0x47, 0x2a, 0x75, 0x45, 0x6f, 0xd0, 0x6d, 0x6d, 0xb4, 0x44, 0x2a, 0x16, 0xc5, 0x56,
   576  	0x2b, 0x0b, 0x25, 0x8b, 0x15, 0xeb, 0x89, 0x6d, 0x03, 0x8b, 0x4d, 0x5d, 0xaf, 0x62, 0x7d, 0xd1,
   577  	0x6f, 0x65, 0xb5, 0xae, 0xcf, 0x8f, 0xd8, 0x56, 0x1c, 0xa9, 0xa2, 0xe1, 0x1d, 0x03, 0xec, 0x69,
   578  	0x61, 0xcd, 0xac, 0x68, 0x14, 0xcc, 0x40, 0x07, 0x6b, 0x34, 0xf2, 0x80, 0x6d, 0xc7, 0x91, 0xba,
   579  	0x88, 0x2e, 0x5d, 0xb1, 0x4b, 0xf8, 0xa3, 0x1a, 0x2f, 0x3e, 0xb5, 0xc8, 0x29, 0xa2, 0xcf, 0x3f,
   580  	0x64, 0xea, 0x6a, 0x52, 0xb1, 0x75, 0x1a, 0x8a, 0xbd, 0xff, 0xa4, 0xe1, 0x5a, 0x1a, 0x1e, 0xbc,
   581  	0x64, 0x7b, 0x4d, 0x3d, 0xfe, 0x80, 0x75, 0xdf, 0x4d, 0xaf, 0xc8, 0x30, 0x3b, 0x93, 0x62, 0xc9,
   582  	0x1f, 0xb3, 0xde, 0xc7, 0xe8, 0xfd, 0x7c, 0x6a, 0xb4, 0x86, 0x37, 0x29, 0x83, 0x67, 0x9d, 0x13,
   583  	0xa8, 0xb5, 0xf0, 0x5e, 0x5a, 0x41, 0x43, 0xcb, 0x91, 0xcc, 0x2e, 0xbe, 0x93, 0x3f, 0x64, 0xdd,
   584  	0x34, 0x53, 0xa5, 0x86, 0x7e, 0xa8, 0xe2, 0x40, 0xc7, 0xf1, 0xdf, 0x38, 0x94, 0xf1, 0x57, 0x14,
   585  	0x6f, 0xfc, 0x2a, 0x18, 0x9e, 0xde, 0x6f, 0x3a, 0xc0, 0xaf, 0x9d, 0xd5, 0xd9, 0xe4, 0x16, 0xd4,
   586  	0xf5, 0xfd, 0xd6, 0xfe, 0xca, 0xfa, 0x41, 0xad, 0x09, 0x9b, 0x5c, 0x85, 0xf5, 0x14, 0x74, 0x36,
   587  	0x39, 0xdb, 0x75, 0x3e, 0x03, 0x15, 0x08, 0xb5, 0xb9, 0xd2, 0xd0, 0x35, 0x56, 0x08, 0x1b, 0xe6,
   588  	0x4a, 0x43, 0x77, 0x45, 0x9b, 0xef, 0x18, 0xea, 0x1a, 0x9a, 0xe1, 0x82, 0xd9, 0x69, 0xa6, 0x5c,
   589  	0x1a, 0xf5, 0xea, 0x76, 0x74, 0xa2, 0x23, 0x48, 0xa3, 0x5d, 0xbd, 0x3b, 0x9d, 0x38, 0x48, 0x7d,
   590  	0x9d, 0xd4, 0x97, 0x31, 0xb5, 0x75, 0xba, 0x36, 0xd2, 0xce, 0x90, 0x72, 0x4e, 0xdb, 0x1e, 0xf3,
   591  	0xac, 0xff, 0xe5, 0xeb, 0x21, 0x5c, 0xff, 0x1c, 0x58, 0xe3, 0xa3, 0xbb, 0x85, 0xb4, 0xfe, 0x2c,
   592  	0x24, 0x5c, 0xe7, 0x12, 0xbe, 0xe5, 0x12, 0xbe, 0xe7, 0x12, 0x6e, 0x72, 0x09, 0xb7, 0xb9, 0x84,
   593  	0xdf, 0xb9, 0x84, 0x4f, 0x4b, 0x69, 0xdd, 0x2e, 0xa5, 0x75, 0xb7, 0x94, 0xd6, 0xdf, 0x00, 0x00,
   594  	0x00, 0xff, 0xff, 0x98, 0xa1, 0x12, 0x2d, 0x51, 0x05, 0x00, 0x00,
   595  }
   596  
   597  func (this *Foo5) Equal(that interface{}) bool {
   598  	if that == nil {
   599  		return this == nil
   600  	}
   601  
   602  	that1, ok := that.(*Foo5)
   603  	if !ok {
   604  		that2, ok := that.(Foo5)
   605  		if ok {
   606  			that1 = &that2
   607  		} else {
   608  			return false
   609  		}
   610  	}
   611  	if that1 == nil {
   612  		return this == nil
   613  	} else if this == nil {
   614  		return false
   615  	}
   616  	if !this.Bar1.Equal(&that1.Bar1) {
   617  		return false
   618  	}
   619  	if !this.Bar2.Equal(that1.Bar2) {
   620  		return false
   621  	}
   622  	if !this.Bar3.Equal(&that1.Bar3) {
   623  		return false
   624  	}
   625  	if !this.Bar4.Equal(that1.Bar4) {
   626  		return false
   627  	}
   628  	if len(this.Bars1) != len(that1.Bars1) {
   629  		return false
   630  	}
   631  	for i := range this.Bars1 {
   632  		if !this.Bars1[i].Equal(&that1.Bars1[i]) {
   633  			return false
   634  		}
   635  	}
   636  	if len(this.Bars2) != len(that1.Bars2) {
   637  		return false
   638  	}
   639  	for i := range this.Bars2 {
   640  		if !this.Bars2[i].Equal(that1.Bars2[i]) {
   641  			return false
   642  		}
   643  	}
   644  	if len(this.Bars3) != len(that1.Bars3) {
   645  		return false
   646  	}
   647  	for i := range this.Bars3 {
   648  		if !this.Bars3[i].Equal(&that1.Bars3[i]) {
   649  			return false
   650  		}
   651  	}
   652  	if len(this.Bars4) != len(that1.Bars4) {
   653  		return false
   654  	}
   655  	for i := range this.Bars4 {
   656  		if !this.Bars4[i].Equal(that1.Bars4[i]) {
   657  			return false
   658  		}
   659  	}
   660  	if len(this.Barrs1) != len(that1.Barrs1) {
   661  		return false
   662  	}
   663  	for i := range this.Barrs1 {
   664  		if !this.Barrs1[i].Equal(&that1.Barrs1[i]) {
   665  			return false
   666  		}
   667  	}
   668  	if len(this.Barrs2) != len(that1.Barrs2) {
   669  		return false
   670  	}
   671  	for i := range this.Barrs2 {
   672  		if !this.Barrs2[i].Equal(&that1.Barrs2[i]) {
   673  			return false
   674  		}
   675  	}
   676  	if len(this.Barmap1) != len(that1.Barmap1) {
   677  		return false
   678  	}
   679  	for i := range this.Barmap1 {
   680  		if !this.Barmap1[i].Equal(that1.Barmap1[i]) {
   681  			return false
   682  		}
   683  	}
   684  	if len(this.Barmap2) != len(that1.Barmap2) {
   685  		return false
   686  	}
   687  	for i := range this.Barmap2 {
   688  		if !this.Barmap2[i].Equal(that1.Barmap2[i]) {
   689  			return false
   690  		}
   691  	}
   692  	return true
   693  }
   694  func (this *Bar1) Equal(that interface{}) bool {
   695  	if that == nil {
   696  		return this == nil
   697  	}
   698  
   699  	that1, ok := that.(*Bar1)
   700  	if !ok {
   701  		that2, ok := that.(Bar1)
   702  		if ok {
   703  			that1 = &that2
   704  		} else {
   705  			return false
   706  		}
   707  	}
   708  	if that1 == nil {
   709  		return this == nil
   710  	} else if this == nil {
   711  		return false
   712  	}
   713  	if this.Str != that1.Str {
   714  		return false
   715  	}
   716  	return true
   717  }
   718  func (this *Bar2) Equal(that interface{}) bool {
   719  	if that == nil {
   720  		return this == nil
   721  	}
   722  
   723  	that1, ok := that.(*Bar2)
   724  	if !ok {
   725  		that2, ok := that.(Bar2)
   726  		if ok {
   727  			that1 = &that2
   728  		} else {
   729  			return false
   730  		}
   731  	}
   732  	if that1 == nil {
   733  		return this == nil
   734  	} else if this == nil {
   735  		return false
   736  	}
   737  	if this.Str != nil && that1.Str != nil {
   738  		if *this.Str != *that1.Str {
   739  			return false
   740  		}
   741  	} else if this.Str != nil {
   742  		return false
   743  	} else if that1.Str != nil {
   744  		return false
   745  	}
   746  	return true
   747  }
   748  func (this *Bar3) Equal(that interface{}) bool {
   749  	if that == nil {
   750  		return this == nil
   751  	}
   752  
   753  	that1, ok := that.(*Bar3)
   754  	if !ok {
   755  		that2, ok := that.(Bar3)
   756  		if ok {
   757  			that1 = &that2
   758  		} else {
   759  			return false
   760  		}
   761  	}
   762  	if that1 == nil {
   763  		return this == nil
   764  	} else if this == nil {
   765  		return false
   766  	}
   767  	if len(this.Bars4) != len(that1.Bars4) {
   768  		return false
   769  	}
   770  	for i := range this.Bars4 {
   771  		if !this.Bars4[i].Equal(&that1.Bars4[i]) {
   772  			return false
   773  		}
   774  	}
   775  	if len(this.Bars2) != len(that1.Bars2) {
   776  		return false
   777  	}
   778  	for i := range this.Bars2 {
   779  		if !this.Bars2[i].Equal(&that1.Bars2[i]) {
   780  			return false
   781  		}
   782  	}
   783  	return true
   784  }
   785  func (this *Bar4) Equal(that interface{}) bool {
   786  	if that == nil {
   787  		return this == nil
   788  	}
   789  
   790  	that1, ok := that.(*Bar4)
   791  	if !ok {
   792  		that2, ok := that.(Bar4)
   793  		if ok {
   794  			that1 = &that2
   795  		} else {
   796  			return false
   797  		}
   798  	}
   799  	if that1 == nil {
   800  		return this == nil
   801  	} else if this == nil {
   802  		return false
   803  	}
   804  	if this.Str != that1.Str {
   805  		return false
   806  	}
   807  	return true
   808  }
   809  func (this *Bar5) Equal(that interface{}) bool {
   810  	if that == nil {
   811  		return this == nil
   812  	}
   813  
   814  	that1, ok := that.(*Bar5)
   815  	if !ok {
   816  		that2, ok := that.(Bar5)
   817  		if ok {
   818  			that1 = &that2
   819  		} else {
   820  			return false
   821  		}
   822  	}
   823  	if that1 == nil {
   824  		return this == nil
   825  	} else if this == nil {
   826  		return false
   827  	}
   828  	if len(this.Bars2) != len(that1.Bars2) {
   829  		return false
   830  	}
   831  	for i := range this.Bars2 {
   832  		if !this.Bars2[i].Equal(that1.Bars2[i]) {
   833  			return false
   834  		}
   835  	}
   836  	if len(this.Bars1) != len(that1.Bars1) {
   837  		return false
   838  	}
   839  	for i := range this.Bars1 {
   840  		if !this.Bars1[i].Equal(that1.Bars1[i]) {
   841  			return false
   842  		}
   843  	}
   844  	return true
   845  }
   846  func (this *Bar7) Equal(that interface{}) bool {
   847  	if that == nil {
   848  		return this == nil
   849  	}
   850  
   851  	that1, ok := that.(*Bar7)
   852  	if !ok {
   853  		that2, ok := that.(Bar7)
   854  		if ok {
   855  			that1 = &that2
   856  		} else {
   857  			return false
   858  		}
   859  	}
   860  	if that1 == nil {
   861  		return this == nil
   862  	} else if this == nil {
   863  		return false
   864  	}
   865  	if len(this.Bars71) != len(that1.Bars71) {
   866  		return false
   867  	}
   868  	for i := range this.Bars71 {
   869  		if !this.Bars71[i].Equal(&that1.Bars71[i]) {
   870  			return false
   871  		}
   872  	}
   873  	if len(this.Bars72) != len(that1.Bars72) {
   874  		return false
   875  	}
   876  	for i := range this.Bars72 {
   877  		if !this.Bars72[i].Equal(that1.Bars72[i]) {
   878  			return false
   879  		}
   880  	}
   881  	if this.Str1 != that1.Str1 {
   882  		return false
   883  	}
   884  	if this.Str2 != nil && that1.Str2 != nil {
   885  		if *this.Str2 != *that1.Str2 {
   886  			return false
   887  		}
   888  	} else if this.Str2 != nil {
   889  		return false
   890  	} else if that1.Str2 != nil {
   891  		return false
   892  	}
   893  	return true
   894  }
   895  func (this *Bar8) Equal(that interface{}) bool {
   896  	if that == nil {
   897  		return this == nil
   898  	}
   899  
   900  	that1, ok := that.(*Bar8)
   901  	if !ok {
   902  		that2, ok := that.(Bar8)
   903  		if ok {
   904  			that1 = &that2
   905  		} else {
   906  			return false
   907  		}
   908  	}
   909  	if that1 == nil {
   910  		return this == nil
   911  	} else if this == nil {
   912  		return false
   913  	}
   914  	if len(this.Bars1) != len(that1.Bars1) {
   915  		return false
   916  	}
   917  	for i := range this.Bars1 {
   918  		if !this.Bars1[i].Equal(&that1.Bars1[i]) {
   919  			return false
   920  		}
   921  	}
   922  	return true
   923  }
   924  func (this *Bar9) Equal(that interface{}) bool {
   925  	if that == nil {
   926  		return this == nil
   927  	}
   928  
   929  	that1, ok := that.(*Bar9)
   930  	if !ok {
   931  		that2, ok := that.(Bar9)
   932  		if ok {
   933  			that1 = &that2
   934  		} else {
   935  			return false
   936  		}
   937  	}
   938  	if that1 == nil {
   939  		return this == nil
   940  	} else if this == nil {
   941  		return false
   942  	}
   943  	if this.Str != that1.Str {
   944  		return false
   945  	}
   946  	return true
   947  }
   948  func (m *Foo5) Marshal() (dAtA []byte, err error) {
   949  	size := m.Size()
   950  	dAtA = make([]byte, size)
   951  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   952  	if err != nil {
   953  		return nil, err
   954  	}
   955  	return dAtA[:n], nil
   956  }
   957  
   958  func (m *Foo5) MarshalTo(dAtA []byte) (int, error) {
   959  	size := m.Size()
   960  	return m.MarshalToSizedBuffer(dAtA[:size])
   961  }
   962  
   963  func (m *Foo5) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   964  	i := len(dAtA)
   965  	_ = i
   966  	var l int
   967  	_ = l
   968  	if len(m.Barmap2) > 0 {
   969  		for k := range m.Barmap2 {
   970  			v := m.Barmap2[k]
   971  			baseI := i
   972  			if v != nil {
   973  				{
   974  					size, err := v.MarshalToSizedBuffer(dAtA[:i])
   975  					if err != nil {
   976  						return 0, err
   977  					}
   978  					i -= size
   979  					i = encodeVarintIssue530(dAtA, i, uint64(size))
   980  				}
   981  				i--
   982  				dAtA[i] = 0x12
   983  			}
   984  			i -= len(k)
   985  			copy(dAtA[i:], k)
   986  			i = encodeVarintIssue530(dAtA, i, uint64(len(k)))
   987  			i--
   988  			dAtA[i] = 0xa
   989  			i = encodeVarintIssue530(dAtA, i, uint64(baseI-i))
   990  			i--
   991  			dAtA[i] = 0x62
   992  		}
   993  	}
   994  	if len(m.Barmap1) > 0 {
   995  		for k := range m.Barmap1 {
   996  			v := m.Barmap1[k]
   997  			baseI := i
   998  			if v != nil {
   999  				{
  1000  					size, err := v.MarshalToSizedBuffer(dAtA[:i])
  1001  					if err != nil {
  1002  						return 0, err
  1003  					}
  1004  					i -= size
  1005  					i = encodeVarintIssue530(dAtA, i, uint64(size))
  1006  				}
  1007  				i--
  1008  				dAtA[i] = 0x12
  1009  			}
  1010  			i -= len(k)
  1011  			copy(dAtA[i:], k)
  1012  			i = encodeVarintIssue530(dAtA, i, uint64(len(k)))
  1013  			i--
  1014  			dAtA[i] = 0xa
  1015  			i = encodeVarintIssue530(dAtA, i, uint64(baseI-i))
  1016  			i--
  1017  			dAtA[i] = 0x5a
  1018  		}
  1019  	}
  1020  	if len(m.Barrs2) > 0 {
  1021  		for iNdEx := len(m.Barrs2) - 1; iNdEx >= 0; iNdEx-- {
  1022  			{
  1023  				size, err := m.Barrs2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1024  				if err != nil {
  1025  					return 0, err
  1026  				}
  1027  				i -= size
  1028  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1029  			}
  1030  			i--
  1031  			dAtA[i] = 0x52
  1032  		}
  1033  	}
  1034  	if len(m.Barrs1) > 0 {
  1035  		for iNdEx := len(m.Barrs1) - 1; iNdEx >= 0; iNdEx-- {
  1036  			{
  1037  				size, err := m.Barrs1[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1038  				if err != nil {
  1039  					return 0, err
  1040  				}
  1041  				i -= size
  1042  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1043  			}
  1044  			i--
  1045  			dAtA[i] = 0x4a
  1046  		}
  1047  	}
  1048  	if len(m.Bars4) > 0 {
  1049  		for iNdEx := len(m.Bars4) - 1; iNdEx >= 0; iNdEx-- {
  1050  			{
  1051  				size, err := m.Bars4[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1052  				if err != nil {
  1053  					return 0, err
  1054  				}
  1055  				i -= size
  1056  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1057  			}
  1058  			i--
  1059  			dAtA[i] = 0x42
  1060  		}
  1061  	}
  1062  	if len(m.Bars3) > 0 {
  1063  		for iNdEx := len(m.Bars3) - 1; iNdEx >= 0; iNdEx-- {
  1064  			{
  1065  				size, err := m.Bars3[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1066  				if err != nil {
  1067  					return 0, err
  1068  				}
  1069  				i -= size
  1070  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1071  			}
  1072  			i--
  1073  			dAtA[i] = 0x3a
  1074  		}
  1075  	}
  1076  	if len(m.Bars2) > 0 {
  1077  		for iNdEx := len(m.Bars2) - 1; iNdEx >= 0; iNdEx-- {
  1078  			{
  1079  				size, err := m.Bars2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1080  				if err != nil {
  1081  					return 0, err
  1082  				}
  1083  				i -= size
  1084  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1085  			}
  1086  			i--
  1087  			dAtA[i] = 0x32
  1088  		}
  1089  	}
  1090  	if len(m.Bars1) > 0 {
  1091  		for iNdEx := len(m.Bars1) - 1; iNdEx >= 0; iNdEx-- {
  1092  			{
  1093  				size, err := m.Bars1[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1094  				if err != nil {
  1095  					return 0, err
  1096  				}
  1097  				i -= size
  1098  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1099  			}
  1100  			i--
  1101  			dAtA[i] = 0x2a
  1102  		}
  1103  	}
  1104  	if m.Bar4 != nil {
  1105  		{
  1106  			size, err := m.Bar4.MarshalToSizedBuffer(dAtA[:i])
  1107  			if err != nil {
  1108  				return 0, err
  1109  			}
  1110  			i -= size
  1111  			i = encodeVarintIssue530(dAtA, i, uint64(size))
  1112  		}
  1113  		i--
  1114  		dAtA[i] = 0x22
  1115  	}
  1116  	{
  1117  		size, err := m.Bar3.MarshalToSizedBuffer(dAtA[:i])
  1118  		if err != nil {
  1119  			return 0, err
  1120  		}
  1121  		i -= size
  1122  		i = encodeVarintIssue530(dAtA, i, uint64(size))
  1123  	}
  1124  	i--
  1125  	dAtA[i] = 0x1a
  1126  	if m.Bar2 != nil {
  1127  		{
  1128  			size, err := m.Bar2.MarshalToSizedBuffer(dAtA[:i])
  1129  			if err != nil {
  1130  				return 0, err
  1131  			}
  1132  			i -= size
  1133  			i = encodeVarintIssue530(dAtA, i, uint64(size))
  1134  		}
  1135  		i--
  1136  		dAtA[i] = 0x12
  1137  	}
  1138  	{
  1139  		size, err := m.Bar1.MarshalToSizedBuffer(dAtA[:i])
  1140  		if err != nil {
  1141  			return 0, err
  1142  		}
  1143  		i -= size
  1144  		i = encodeVarintIssue530(dAtA, i, uint64(size))
  1145  	}
  1146  	i--
  1147  	dAtA[i] = 0xa
  1148  	return len(dAtA) - i, nil
  1149  }
  1150  
  1151  func (m *Bar1) Marshal() (dAtA []byte, err error) {
  1152  	size := m.Size()
  1153  	dAtA = make([]byte, size)
  1154  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1155  	if err != nil {
  1156  		return nil, err
  1157  	}
  1158  	return dAtA[:n], nil
  1159  }
  1160  
  1161  func (m *Bar1) MarshalTo(dAtA []byte) (int, error) {
  1162  	size := m.Size()
  1163  	return m.MarshalToSizedBuffer(dAtA[:size])
  1164  }
  1165  
  1166  func (m *Bar1) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1167  	i := len(dAtA)
  1168  	_ = i
  1169  	var l int
  1170  	_ = l
  1171  	i -= len(m.Str)
  1172  	copy(dAtA[i:], m.Str)
  1173  	i = encodeVarintIssue530(dAtA, i, uint64(len(m.Str)))
  1174  	i--
  1175  	dAtA[i] = 0xa
  1176  	return len(dAtA) - i, nil
  1177  }
  1178  
  1179  func (m *Bar2) Marshal() (dAtA []byte, err error) {
  1180  	size := m.Size()
  1181  	dAtA = make([]byte, size)
  1182  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1183  	if err != nil {
  1184  		return nil, err
  1185  	}
  1186  	return dAtA[:n], nil
  1187  }
  1188  
  1189  func (m *Bar2) MarshalTo(dAtA []byte) (int, error) {
  1190  	size := m.Size()
  1191  	return m.MarshalToSizedBuffer(dAtA[:size])
  1192  }
  1193  
  1194  func (m *Bar2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1195  	i := len(dAtA)
  1196  	_ = i
  1197  	var l int
  1198  	_ = l
  1199  	if m.Str != nil {
  1200  		i -= len(*m.Str)
  1201  		copy(dAtA[i:], *m.Str)
  1202  		i = encodeVarintIssue530(dAtA, i, uint64(len(*m.Str)))
  1203  		i--
  1204  		dAtA[i] = 0xa
  1205  	}
  1206  	return len(dAtA) - i, nil
  1207  }
  1208  
  1209  func (m *Bar3) Marshal() (dAtA []byte, err error) {
  1210  	size := m.Size()
  1211  	dAtA = make([]byte, size)
  1212  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1213  	if err != nil {
  1214  		return nil, err
  1215  	}
  1216  	return dAtA[:n], nil
  1217  }
  1218  
  1219  func (m *Bar3) MarshalTo(dAtA []byte) (int, error) {
  1220  	size := m.Size()
  1221  	return m.MarshalToSizedBuffer(dAtA[:size])
  1222  }
  1223  
  1224  func (m *Bar3) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1225  	i := len(dAtA)
  1226  	_ = i
  1227  	var l int
  1228  	_ = l
  1229  	if len(m.Bars2) > 0 {
  1230  		for iNdEx := len(m.Bars2) - 1; iNdEx >= 0; iNdEx-- {
  1231  			{
  1232  				size, err := m.Bars2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1233  				if err != nil {
  1234  					return 0, err
  1235  				}
  1236  				i -= size
  1237  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1238  			}
  1239  			i--
  1240  			dAtA[i] = 0x12
  1241  		}
  1242  	}
  1243  	if len(m.Bars4) > 0 {
  1244  		for iNdEx := len(m.Bars4) - 1; iNdEx >= 0; iNdEx-- {
  1245  			{
  1246  				size, err := m.Bars4[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1247  				if err != nil {
  1248  					return 0, err
  1249  				}
  1250  				i -= size
  1251  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1252  			}
  1253  			i--
  1254  			dAtA[i] = 0xa
  1255  		}
  1256  	}
  1257  	return len(dAtA) - i, nil
  1258  }
  1259  
  1260  func (m *Bar4) Marshal() (dAtA []byte, err error) {
  1261  	size := m.Size()
  1262  	dAtA = make([]byte, size)
  1263  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1264  	if err != nil {
  1265  		return nil, err
  1266  	}
  1267  	return dAtA[:n], nil
  1268  }
  1269  
  1270  func (m *Bar4) MarshalTo(dAtA []byte) (int, error) {
  1271  	size := m.Size()
  1272  	return m.MarshalToSizedBuffer(dAtA[:size])
  1273  }
  1274  
  1275  func (m *Bar4) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1276  	i := len(dAtA)
  1277  	_ = i
  1278  	var l int
  1279  	_ = l
  1280  	i -= len(m.Str)
  1281  	copy(dAtA[i:], m.Str)
  1282  	i = encodeVarintIssue530(dAtA, i, uint64(len(m.Str)))
  1283  	i--
  1284  	dAtA[i] = 0xa
  1285  	return len(dAtA) - i, nil
  1286  }
  1287  
  1288  func (m *Bar5) Marshal() (dAtA []byte, err error) {
  1289  	size := m.Size()
  1290  	dAtA = make([]byte, size)
  1291  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1292  	if err != nil {
  1293  		return nil, err
  1294  	}
  1295  	return dAtA[:n], nil
  1296  }
  1297  
  1298  func (m *Bar5) MarshalTo(dAtA []byte) (int, error) {
  1299  	size := m.Size()
  1300  	return m.MarshalToSizedBuffer(dAtA[:size])
  1301  }
  1302  
  1303  func (m *Bar5) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1304  	i := len(dAtA)
  1305  	_ = i
  1306  	var l int
  1307  	_ = l
  1308  	if len(m.Bars1) > 0 {
  1309  		for iNdEx := len(m.Bars1) - 1; iNdEx >= 0; iNdEx-- {
  1310  			{
  1311  				size, err := m.Bars1[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1312  				if err != nil {
  1313  					return 0, err
  1314  				}
  1315  				i -= size
  1316  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1317  			}
  1318  			i--
  1319  			dAtA[i] = 0x12
  1320  		}
  1321  	}
  1322  	if len(m.Bars2) > 0 {
  1323  		for iNdEx := len(m.Bars2) - 1; iNdEx >= 0; iNdEx-- {
  1324  			{
  1325  				size, err := m.Bars2[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1326  				if err != nil {
  1327  					return 0, err
  1328  				}
  1329  				i -= size
  1330  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1331  			}
  1332  			i--
  1333  			dAtA[i] = 0xa
  1334  		}
  1335  	}
  1336  	return len(dAtA) - i, nil
  1337  }
  1338  
  1339  func (m *Bar7) Marshal() (dAtA []byte, err error) {
  1340  	size := m.Size()
  1341  	dAtA = make([]byte, size)
  1342  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1343  	if err != nil {
  1344  		return nil, err
  1345  	}
  1346  	return dAtA[:n], nil
  1347  }
  1348  
  1349  func (m *Bar7) MarshalTo(dAtA []byte) (int, error) {
  1350  	size := m.Size()
  1351  	return m.MarshalToSizedBuffer(dAtA[:size])
  1352  }
  1353  
  1354  func (m *Bar7) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1355  	i := len(dAtA)
  1356  	_ = i
  1357  	var l int
  1358  	_ = l
  1359  	if m.Str2 != nil {
  1360  		i -= len(*m.Str2)
  1361  		copy(dAtA[i:], *m.Str2)
  1362  		i = encodeVarintIssue530(dAtA, i, uint64(len(*m.Str2)))
  1363  		i--
  1364  		dAtA[i] = 0x22
  1365  	}
  1366  	i -= len(m.Str1)
  1367  	copy(dAtA[i:], m.Str1)
  1368  	i = encodeVarintIssue530(dAtA, i, uint64(len(m.Str1)))
  1369  	i--
  1370  	dAtA[i] = 0x1a
  1371  	if len(m.Bars72) > 0 {
  1372  		for iNdEx := len(m.Bars72) - 1; iNdEx >= 0; iNdEx-- {
  1373  			{
  1374  				size, err := m.Bars72[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1375  				if err != nil {
  1376  					return 0, err
  1377  				}
  1378  				i -= size
  1379  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1380  			}
  1381  			i--
  1382  			dAtA[i] = 0x12
  1383  		}
  1384  	}
  1385  	if len(m.Bars71) > 0 {
  1386  		for iNdEx := len(m.Bars71) - 1; iNdEx >= 0; iNdEx-- {
  1387  			{
  1388  				size, err := m.Bars71[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1389  				if err != nil {
  1390  					return 0, err
  1391  				}
  1392  				i -= size
  1393  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1394  			}
  1395  			i--
  1396  			dAtA[i] = 0xa
  1397  		}
  1398  	}
  1399  	return len(dAtA) - i, nil
  1400  }
  1401  
  1402  func (m *Bar8) Marshal() (dAtA []byte, err error) {
  1403  	size := m.Size()
  1404  	dAtA = make([]byte, size)
  1405  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1406  	if err != nil {
  1407  		return nil, err
  1408  	}
  1409  	return dAtA[:n], nil
  1410  }
  1411  
  1412  func (m *Bar8) MarshalTo(dAtA []byte) (int, error) {
  1413  	size := m.Size()
  1414  	return m.MarshalToSizedBuffer(dAtA[:size])
  1415  }
  1416  
  1417  func (m *Bar8) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1418  	i := len(dAtA)
  1419  	_ = i
  1420  	var l int
  1421  	_ = l
  1422  	if len(m.Bars1) > 0 {
  1423  		for iNdEx := len(m.Bars1) - 1; iNdEx >= 0; iNdEx-- {
  1424  			{
  1425  				size, err := m.Bars1[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1426  				if err != nil {
  1427  					return 0, err
  1428  				}
  1429  				i -= size
  1430  				i = encodeVarintIssue530(dAtA, i, uint64(size))
  1431  			}
  1432  			i--
  1433  			dAtA[i] = 0xa
  1434  		}
  1435  	}
  1436  	return len(dAtA) - i, nil
  1437  }
  1438  
  1439  func (m *Bar9) Marshal() (dAtA []byte, err error) {
  1440  	size := m.Size()
  1441  	dAtA = make([]byte, size)
  1442  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1443  	if err != nil {
  1444  		return nil, err
  1445  	}
  1446  	return dAtA[:n], nil
  1447  }
  1448  
  1449  func (m *Bar9) MarshalTo(dAtA []byte) (int, error) {
  1450  	size := m.Size()
  1451  	return m.MarshalToSizedBuffer(dAtA[:size])
  1452  }
  1453  
  1454  func (m *Bar9) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1455  	i := len(dAtA)
  1456  	_ = i
  1457  	var l int
  1458  	_ = l
  1459  	i -= len(m.Str)
  1460  	copy(dAtA[i:], m.Str)
  1461  	i = encodeVarintIssue530(dAtA, i, uint64(len(m.Str)))
  1462  	i--
  1463  	dAtA[i] = 0xa
  1464  	return len(dAtA) - i, nil
  1465  }
  1466  
  1467  func encodeVarintIssue530(dAtA []byte, offset int, v uint64) int {
  1468  	offset -= sovIssue530(v)
  1469  	base := offset
  1470  	for v >= 1<<7 {
  1471  		dAtA[offset] = uint8(v&0x7f | 0x80)
  1472  		v >>= 7
  1473  		offset++
  1474  	}
  1475  	dAtA[offset] = uint8(v)
  1476  	return base
  1477  }
  1478  func NewPopulatedFoo5(r randyIssue530, easy bool) *Foo5 {
  1479  	this := &Foo5{}
  1480  	v1 := NewPopulatedBar1(r, easy)
  1481  	this.Bar1 = *v1
  1482  	if r.Intn(5) != 0 {
  1483  		this.Bar2 = NewPopulatedBar1(r, easy)
  1484  	}
  1485  	v2 := NewPopulatedBar2(r, easy)
  1486  	this.Bar3 = *v2
  1487  	if r.Intn(5) != 0 {
  1488  		this.Bar4 = NewPopulatedBar2(r, easy)
  1489  	}
  1490  	if r.Intn(5) != 0 {
  1491  		v3 := r.Intn(5)
  1492  		this.Bars1 = make([]Bar1, v3)
  1493  		for i := 0; i < v3; i++ {
  1494  			v4 := NewPopulatedBar1(r, easy)
  1495  			this.Bars1[i] = *v4
  1496  		}
  1497  	}
  1498  	if r.Intn(5) != 0 {
  1499  		v5 := r.Intn(5)
  1500  		this.Bars2 = make([]*Bar1, v5)
  1501  		for i := 0; i < v5; i++ {
  1502  			this.Bars2[i] = NewPopulatedBar1(r, easy)
  1503  		}
  1504  	}
  1505  	if r.Intn(5) != 0 {
  1506  		v6 := r.Intn(5)
  1507  		this.Bars3 = make([]Bar2, v6)
  1508  		for i := 0; i < v6; i++ {
  1509  			v7 := NewPopulatedBar2(r, easy)
  1510  			this.Bars3[i] = *v7
  1511  		}
  1512  	}
  1513  	if r.Intn(5) != 0 {
  1514  		v8 := r.Intn(5)
  1515  		this.Bars4 = make([]*Bar2, v8)
  1516  		for i := 0; i < v8; i++ {
  1517  			this.Bars4[i] = NewPopulatedBar2(r, easy)
  1518  		}
  1519  	}
  1520  	if r.Intn(5) != 0 {
  1521  		v9 := r.Intn(5)
  1522  		this.Barrs1 = make([]Bar3, v9)
  1523  		for i := 0; i < v9; i++ {
  1524  			v10 := NewPopulatedBar3(r, easy)
  1525  			this.Barrs1[i] = *v10
  1526  		}
  1527  	}
  1528  	if r.Intn(5) != 0 {
  1529  		v11 := r.Intn(5)
  1530  		this.Barrs2 = make([]Bar5, v11)
  1531  		for i := 0; i < v11; i++ {
  1532  			v12 := NewPopulatedBar5(r, easy)
  1533  			this.Barrs2[i] = *v12
  1534  		}
  1535  	}
  1536  	if r.Intn(5) != 0 {
  1537  		v13 := r.Intn(10)
  1538  		this.Barmap1 = make(map[string]*Bar3)
  1539  		for i := 0; i < v13; i++ {
  1540  			this.Barmap1[randStringIssue530(r)] = NewPopulatedBar3(r, easy)
  1541  		}
  1542  	}
  1543  	if r.Intn(5) != 0 {
  1544  		v14 := r.Intn(10)
  1545  		this.Barmap2 = make(map[string]*Bar5)
  1546  		for i := 0; i < v14; i++ {
  1547  			this.Barmap2[randStringIssue530(r)] = NewPopulatedBar5(r, easy)
  1548  		}
  1549  	}
  1550  	if !easy && r.Intn(10) != 0 {
  1551  	}
  1552  	return this
  1553  }
  1554  
  1555  func NewPopulatedBar1(r randyIssue530, easy bool) *Bar1 {
  1556  	this := &Bar1{}
  1557  	this.Str = string(randStringIssue530(r))
  1558  	if !easy && r.Intn(10) != 0 {
  1559  	}
  1560  	return this
  1561  }
  1562  
  1563  func NewPopulatedBar2(r randyIssue530, easy bool) *Bar2 {
  1564  	this := &Bar2{}
  1565  	if r.Intn(5) != 0 {
  1566  		v15 := string(randStringIssue530(r))
  1567  		this.Str = &v15
  1568  	}
  1569  	if !easy && r.Intn(10) != 0 {
  1570  	}
  1571  	return this
  1572  }
  1573  
  1574  func NewPopulatedBar3(r randyIssue530, easy bool) *Bar3 {
  1575  	this := &Bar3{}
  1576  	if r.Intn(5) != 0 {
  1577  		v16 := r.Intn(5)
  1578  		this.Bars4 = make([]Bar4, v16)
  1579  		for i := 0; i < v16; i++ {
  1580  			v17 := NewPopulatedBar4(r, easy)
  1581  			this.Bars4[i] = *v17
  1582  		}
  1583  	}
  1584  	if r.Intn(5) != 0 {
  1585  		v18 := r.Intn(5)
  1586  		this.Bars2 = make([]Bar2, v18)
  1587  		for i := 0; i < v18; i++ {
  1588  			v19 := NewPopulatedBar2(r, easy)
  1589  			this.Bars2[i] = *v19
  1590  		}
  1591  	}
  1592  	if !easy && r.Intn(10) != 0 {
  1593  	}
  1594  	return this
  1595  }
  1596  
  1597  func NewPopulatedBar4(r randyIssue530, easy bool) *Bar4 {
  1598  	this := &Bar4{}
  1599  	this.Str = string(randStringIssue530(r))
  1600  	if !easy && r.Intn(10) != 0 {
  1601  	}
  1602  	return this
  1603  }
  1604  
  1605  func NewPopulatedBar5(r randyIssue530, easy bool) *Bar5 {
  1606  	this := &Bar5{}
  1607  	if r.Intn(5) != 0 {
  1608  		v20 := r.Intn(5)
  1609  		this.Bars2 = make([]*Bar2, v20)
  1610  		for i := 0; i < v20; i++ {
  1611  			this.Bars2[i] = NewPopulatedBar2(r, easy)
  1612  		}
  1613  	}
  1614  	if r.Intn(5) != 0 {
  1615  		v21 := r.Intn(5)
  1616  		this.Bars1 = make([]*Bar1, v21)
  1617  		for i := 0; i < v21; i++ {
  1618  			this.Bars1[i] = NewPopulatedBar1(r, easy)
  1619  		}
  1620  	}
  1621  	if !easy && r.Intn(10) != 0 {
  1622  	}
  1623  	return this
  1624  }
  1625  
  1626  func NewPopulatedBar7(r randyIssue530, easy bool) *Bar7 {
  1627  	this := &Bar7{}
  1628  	if r.Intn(5) == 0 {
  1629  		v22 := r.Intn(5)
  1630  		this.Bars71 = make([]Bar7, v22)
  1631  		for i := 0; i < v22; i++ {
  1632  			v23 := NewPopulatedBar7(r, easy)
  1633  			this.Bars71[i] = *v23
  1634  		}
  1635  	}
  1636  	if r.Intn(5) == 0 {
  1637  		v24 := r.Intn(5)
  1638  		this.Bars72 = make([]*Bar7, v24)
  1639  		for i := 0; i < v24; i++ {
  1640  			this.Bars72[i] = NewPopulatedBar7(r, easy)
  1641  		}
  1642  	}
  1643  	this.Str1 = string(randStringIssue530(r))
  1644  	if r.Intn(5) != 0 {
  1645  		v25 := string(randStringIssue530(r))
  1646  		this.Str2 = &v25
  1647  	}
  1648  	if !easy && r.Intn(10) != 0 {
  1649  	}
  1650  	return this
  1651  }
  1652  
  1653  func NewPopulatedBar8(r randyIssue530, easy bool) *Bar8 {
  1654  	this := &Bar8{}
  1655  	if r.Intn(5) != 0 {
  1656  		v26 := r.Intn(5)
  1657  		this.Bars1 = make([]Bar9, v26)
  1658  		for i := 0; i < v26; i++ {
  1659  			v27 := NewPopulatedBar9(r, easy)
  1660  			this.Bars1[i] = *v27
  1661  		}
  1662  	}
  1663  	if !easy && r.Intn(10) != 0 {
  1664  	}
  1665  	return this
  1666  }
  1667  
  1668  func NewPopulatedBar9(r randyIssue530, easy bool) *Bar9 {
  1669  	this := &Bar9{}
  1670  	this.Str = string(randStringIssue530(r))
  1671  	if !easy && r.Intn(10) != 0 {
  1672  	}
  1673  	return this
  1674  }
  1675  
  1676  type randyIssue530 interface {
  1677  	Float32() float32
  1678  	Float64() float64
  1679  	Int63() int64
  1680  	Int31() int32
  1681  	Uint32() uint32
  1682  	Intn(n int) int
  1683  }
  1684  
  1685  func randUTF8RuneIssue530(r randyIssue530) rune {
  1686  	ru := r.Intn(62)
  1687  	if ru < 10 {
  1688  		return rune(ru + 48)
  1689  	} else if ru < 36 {
  1690  		return rune(ru + 55)
  1691  	}
  1692  	return rune(ru + 61)
  1693  }
  1694  func randStringIssue530(r randyIssue530) string {
  1695  	v28 := r.Intn(100)
  1696  	tmps := make([]rune, v28)
  1697  	for i := 0; i < v28; i++ {
  1698  		tmps[i] = randUTF8RuneIssue530(r)
  1699  	}
  1700  	return string(tmps)
  1701  }
  1702  func randUnrecognizedIssue530(r randyIssue530, maxFieldNumber int) (dAtA []byte) {
  1703  	l := r.Intn(5)
  1704  	for i := 0; i < l; i++ {
  1705  		wire := r.Intn(4)
  1706  		if wire == 3 {
  1707  			wire = 5
  1708  		}
  1709  		fieldNumber := maxFieldNumber + r.Intn(100)
  1710  		dAtA = randFieldIssue530(dAtA, r, fieldNumber, wire)
  1711  	}
  1712  	return dAtA
  1713  }
  1714  func randFieldIssue530(dAtA []byte, r randyIssue530, fieldNumber int, wire int) []byte {
  1715  	key := uint32(fieldNumber)<<3 | uint32(wire)
  1716  	switch wire {
  1717  	case 0:
  1718  		dAtA = encodeVarintPopulateIssue530(dAtA, uint64(key))
  1719  		v29 := r.Int63()
  1720  		if r.Intn(2) == 0 {
  1721  			v29 *= -1
  1722  		}
  1723  		dAtA = encodeVarintPopulateIssue530(dAtA, uint64(v29))
  1724  	case 1:
  1725  		dAtA = encodeVarintPopulateIssue530(dAtA, uint64(key))
  1726  		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)))
  1727  	case 2:
  1728  		dAtA = encodeVarintPopulateIssue530(dAtA, uint64(key))
  1729  		ll := r.Intn(100)
  1730  		dAtA = encodeVarintPopulateIssue530(dAtA, uint64(ll))
  1731  		for j := 0; j < ll; j++ {
  1732  			dAtA = append(dAtA, byte(r.Intn(256)))
  1733  		}
  1734  	default:
  1735  		dAtA = encodeVarintPopulateIssue530(dAtA, uint64(key))
  1736  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
  1737  	}
  1738  	return dAtA
  1739  }
  1740  func encodeVarintPopulateIssue530(dAtA []byte, v uint64) []byte {
  1741  	for v >= 1<<7 {
  1742  		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
  1743  		v >>= 7
  1744  	}
  1745  	dAtA = append(dAtA, uint8(v))
  1746  	return dAtA
  1747  }
  1748  func (m *Foo5) Size() (n int) {
  1749  	if m == nil {
  1750  		return 0
  1751  	}
  1752  	var l int
  1753  	_ = l
  1754  	l = m.Bar1.Size()
  1755  	n += 1 + l + sovIssue530(uint64(l))
  1756  	if m.Bar2 != nil {
  1757  		l = m.Bar2.Size()
  1758  		n += 1 + l + sovIssue530(uint64(l))
  1759  	}
  1760  	l = m.Bar3.Size()
  1761  	n += 1 + l + sovIssue530(uint64(l))
  1762  	if m.Bar4 != nil {
  1763  		l = m.Bar4.Size()
  1764  		n += 1 + l + sovIssue530(uint64(l))
  1765  	}
  1766  	if len(m.Bars1) > 0 {
  1767  		for _, e := range m.Bars1 {
  1768  			l = e.Size()
  1769  			n += 1 + l + sovIssue530(uint64(l))
  1770  		}
  1771  	}
  1772  	if len(m.Bars2) > 0 {
  1773  		for _, e := range m.Bars2 {
  1774  			l = e.Size()
  1775  			n += 1 + l + sovIssue530(uint64(l))
  1776  		}
  1777  	}
  1778  	if len(m.Bars3) > 0 {
  1779  		for _, e := range m.Bars3 {
  1780  			l = e.Size()
  1781  			n += 1 + l + sovIssue530(uint64(l))
  1782  		}
  1783  	}
  1784  	if len(m.Bars4) > 0 {
  1785  		for _, e := range m.Bars4 {
  1786  			l = e.Size()
  1787  			n += 1 + l + sovIssue530(uint64(l))
  1788  		}
  1789  	}
  1790  	if len(m.Barrs1) > 0 {
  1791  		for _, e := range m.Barrs1 {
  1792  			l = e.Size()
  1793  			n += 1 + l + sovIssue530(uint64(l))
  1794  		}
  1795  	}
  1796  	if len(m.Barrs2) > 0 {
  1797  		for _, e := range m.Barrs2 {
  1798  			l = e.Size()
  1799  			n += 1 + l + sovIssue530(uint64(l))
  1800  		}
  1801  	}
  1802  	if len(m.Barmap1) > 0 {
  1803  		for k, v := range m.Barmap1 {
  1804  			_ = k
  1805  			_ = v
  1806  			l = 0
  1807  			if v != nil {
  1808  				l = v.Size()
  1809  				l += 1 + sovIssue530(uint64(l))
  1810  			}
  1811  			mapEntrySize := 1 + len(k) + sovIssue530(uint64(len(k))) + l
  1812  			n += mapEntrySize + 1 + sovIssue530(uint64(mapEntrySize))
  1813  		}
  1814  	}
  1815  	if len(m.Barmap2) > 0 {
  1816  		for k, v := range m.Barmap2 {
  1817  			_ = k
  1818  			_ = v
  1819  			l = 0
  1820  			if v != nil {
  1821  				l = v.Size()
  1822  				l += 1 + sovIssue530(uint64(l))
  1823  			}
  1824  			mapEntrySize := 1 + len(k) + sovIssue530(uint64(len(k))) + l
  1825  			n += mapEntrySize + 1 + sovIssue530(uint64(mapEntrySize))
  1826  		}
  1827  	}
  1828  	return n
  1829  }
  1830  
  1831  func (m *Bar1) Size() (n int) {
  1832  	if m == nil {
  1833  		return 0
  1834  	}
  1835  	var l int
  1836  	_ = l
  1837  	l = len(m.Str)
  1838  	n += 1 + l + sovIssue530(uint64(l))
  1839  	return n
  1840  }
  1841  
  1842  func (m *Bar2) Size() (n int) {
  1843  	if m == nil {
  1844  		return 0
  1845  	}
  1846  	var l int
  1847  	_ = l
  1848  	if m.Str != nil {
  1849  		l = len(*m.Str)
  1850  		n += 1 + l + sovIssue530(uint64(l))
  1851  	}
  1852  	return n
  1853  }
  1854  
  1855  func (m *Bar3) Size() (n int) {
  1856  	if m == nil {
  1857  		return 0
  1858  	}
  1859  	var l int
  1860  	_ = l
  1861  	if len(m.Bars4) > 0 {
  1862  		for _, e := range m.Bars4 {
  1863  			l = e.Size()
  1864  			n += 1 + l + sovIssue530(uint64(l))
  1865  		}
  1866  	}
  1867  	if len(m.Bars2) > 0 {
  1868  		for _, e := range m.Bars2 {
  1869  			l = e.Size()
  1870  			n += 1 + l + sovIssue530(uint64(l))
  1871  		}
  1872  	}
  1873  	return n
  1874  }
  1875  
  1876  func (m *Bar4) Size() (n int) {
  1877  	if m == nil {
  1878  		return 0
  1879  	}
  1880  	var l int
  1881  	_ = l
  1882  	l = len(m.Str)
  1883  	n += 1 + l + sovIssue530(uint64(l))
  1884  	return n
  1885  }
  1886  
  1887  func (m *Bar5) Size() (n int) {
  1888  	if m == nil {
  1889  		return 0
  1890  	}
  1891  	var l int
  1892  	_ = l
  1893  	if len(m.Bars2) > 0 {
  1894  		for _, e := range m.Bars2 {
  1895  			l = e.Size()
  1896  			n += 1 + l + sovIssue530(uint64(l))
  1897  		}
  1898  	}
  1899  	if len(m.Bars1) > 0 {
  1900  		for _, e := range m.Bars1 {
  1901  			l = e.Size()
  1902  			n += 1 + l + sovIssue530(uint64(l))
  1903  		}
  1904  	}
  1905  	return n
  1906  }
  1907  
  1908  func (m *Bar7) Size() (n int) {
  1909  	if m == nil {
  1910  		return 0
  1911  	}
  1912  	var l int
  1913  	_ = l
  1914  	if len(m.Bars71) > 0 {
  1915  		for _, e := range m.Bars71 {
  1916  			l = e.Size()
  1917  			n += 1 + l + sovIssue530(uint64(l))
  1918  		}
  1919  	}
  1920  	if len(m.Bars72) > 0 {
  1921  		for _, e := range m.Bars72 {
  1922  			l = e.Size()
  1923  			n += 1 + l + sovIssue530(uint64(l))
  1924  		}
  1925  	}
  1926  	l = len(m.Str1)
  1927  	n += 1 + l + sovIssue530(uint64(l))
  1928  	if m.Str2 != nil {
  1929  		l = len(*m.Str2)
  1930  		n += 1 + l + sovIssue530(uint64(l))
  1931  	}
  1932  	return n
  1933  }
  1934  
  1935  func (m *Bar8) Size() (n int) {
  1936  	if m == nil {
  1937  		return 0
  1938  	}
  1939  	var l int
  1940  	_ = l
  1941  	if len(m.Bars1) > 0 {
  1942  		for _, e := range m.Bars1 {
  1943  			l = e.Size()
  1944  			n += 1 + l + sovIssue530(uint64(l))
  1945  		}
  1946  	}
  1947  	return n
  1948  }
  1949  
  1950  func (m *Bar9) Size() (n int) {
  1951  	if m == nil {
  1952  		return 0
  1953  	}
  1954  	var l int
  1955  	_ = l
  1956  	l = len(m.Str)
  1957  	n += 1 + l + sovIssue530(uint64(l))
  1958  	return n
  1959  }
  1960  
  1961  func sovIssue530(x uint64) (n int) {
  1962  	return (math_bits.Len64(x|1) + 6) / 7
  1963  }
  1964  func sozIssue530(x uint64) (n int) {
  1965  	return sovIssue530(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1966  }
  1967  func (this *Foo5) String() string {
  1968  	if this == nil {
  1969  		return "nil"
  1970  	}
  1971  	repeatedStringForBars1 := "[]Bar1{"
  1972  	for _, f := range this.Bars1 {
  1973  		repeatedStringForBars1 += strings.Replace(strings.Replace(f.String(), "Bar1", "Bar1", 1), `&`, ``, 1) + ","
  1974  	}
  1975  	repeatedStringForBars1 += "}"
  1976  	repeatedStringForBars2 := "[]*Bar1{"
  1977  	for _, f := range this.Bars2 {
  1978  		repeatedStringForBars2 += strings.Replace(f.String(), "Bar1", "Bar1", 1) + ","
  1979  	}
  1980  	repeatedStringForBars2 += "}"
  1981  	repeatedStringForBars3 := "[]Bar2{"
  1982  	for _, f := range this.Bars3 {
  1983  		repeatedStringForBars3 += strings.Replace(strings.Replace(f.String(), "Bar2", "Bar2", 1), `&`, ``, 1) + ","
  1984  	}
  1985  	repeatedStringForBars3 += "}"
  1986  	repeatedStringForBars4 := "[]*Bar2{"
  1987  	for _, f := range this.Bars4 {
  1988  		repeatedStringForBars4 += strings.Replace(f.String(), "Bar2", "Bar2", 1) + ","
  1989  	}
  1990  	repeatedStringForBars4 += "}"
  1991  	repeatedStringForBarrs1 := "[]Bar3{"
  1992  	for _, f := range this.Barrs1 {
  1993  		repeatedStringForBarrs1 += strings.Replace(strings.Replace(f.String(), "Bar3", "Bar3", 1), `&`, ``, 1) + ","
  1994  	}
  1995  	repeatedStringForBarrs1 += "}"
  1996  	repeatedStringForBarrs2 := "[]Bar5{"
  1997  	for _, f := range this.Barrs2 {
  1998  		repeatedStringForBarrs2 += strings.Replace(strings.Replace(f.String(), "Bar5", "Bar5", 1), `&`, ``, 1) + ","
  1999  	}
  2000  	repeatedStringForBarrs2 += "}"
  2001  	keysForBarmap1 := make([]string, 0, len(this.Barmap1))
  2002  	for k := range this.Barmap1 {
  2003  		keysForBarmap1 = append(keysForBarmap1, k)
  2004  	}
  2005  	github_com_gogo_protobuf_sortkeys.Strings(keysForBarmap1)
  2006  	mapStringForBarmap1 := "map[string]*Bar3{"
  2007  	for _, k := range keysForBarmap1 {
  2008  		mapStringForBarmap1 += fmt.Sprintf("%v: %v,", k, this.Barmap1[k])
  2009  	}
  2010  	mapStringForBarmap1 += "}"
  2011  	keysForBarmap2 := make([]string, 0, len(this.Barmap2))
  2012  	for k := range this.Barmap2 {
  2013  		keysForBarmap2 = append(keysForBarmap2, k)
  2014  	}
  2015  	github_com_gogo_protobuf_sortkeys.Strings(keysForBarmap2)
  2016  	mapStringForBarmap2 := "map[string]*Bar5{"
  2017  	for _, k := range keysForBarmap2 {
  2018  		mapStringForBarmap2 += fmt.Sprintf("%v: %v,", k, this.Barmap2[k])
  2019  	}
  2020  	mapStringForBarmap2 += "}"
  2021  	s := strings.Join([]string{`&Foo5{`,
  2022  		`Bar1:` + strings.Replace(strings.Replace(this.Bar1.String(), "Bar1", "Bar1", 1), `&`, ``, 1) + `,`,
  2023  		`Bar2:` + strings.Replace(this.Bar2.String(), "Bar1", "Bar1", 1) + `,`,
  2024  		`Bar3:` + strings.Replace(strings.Replace(this.Bar3.String(), "Bar2", "Bar2", 1), `&`, ``, 1) + `,`,
  2025  		`Bar4:` + strings.Replace(this.Bar4.String(), "Bar2", "Bar2", 1) + `,`,
  2026  		`Bars1:` + repeatedStringForBars1 + `,`,
  2027  		`Bars2:` + repeatedStringForBars2 + `,`,
  2028  		`Bars3:` + repeatedStringForBars3 + `,`,
  2029  		`Bars4:` + repeatedStringForBars4 + `,`,
  2030  		`Barrs1:` + repeatedStringForBarrs1 + `,`,
  2031  		`Barrs2:` + repeatedStringForBarrs2 + `,`,
  2032  		`Barmap1:` + mapStringForBarmap1 + `,`,
  2033  		`Barmap2:` + mapStringForBarmap2 + `,`,
  2034  		`}`,
  2035  	}, "")
  2036  	return s
  2037  }
  2038  func (this *Bar1) String() string {
  2039  	if this == nil {
  2040  		return "nil"
  2041  	}
  2042  	s := strings.Join([]string{`&Bar1{`,
  2043  		`Str:` + fmt.Sprintf("%v", this.Str) + `,`,
  2044  		`}`,
  2045  	}, "")
  2046  	return s
  2047  }
  2048  func (this *Bar2) String() string {
  2049  	if this == nil {
  2050  		return "nil"
  2051  	}
  2052  	s := strings.Join([]string{`&Bar2{`,
  2053  		`Str:` + valueToStringIssue530(this.Str) + `,`,
  2054  		`}`,
  2055  	}, "")
  2056  	return s
  2057  }
  2058  func (this *Bar3) String() string {
  2059  	if this == nil {
  2060  		return "nil"
  2061  	}
  2062  	repeatedStringForBars4 := "[]Bar4{"
  2063  	for _, f := range this.Bars4 {
  2064  		repeatedStringForBars4 += strings.Replace(strings.Replace(f.String(), "Bar4", "Bar4", 1), `&`, ``, 1) + ","
  2065  	}
  2066  	repeatedStringForBars4 += "}"
  2067  	repeatedStringForBars2 := "[]Bar2{"
  2068  	for _, f := range this.Bars2 {
  2069  		repeatedStringForBars2 += strings.Replace(strings.Replace(f.String(), "Bar2", "Bar2", 1), `&`, ``, 1) + ","
  2070  	}
  2071  	repeatedStringForBars2 += "}"
  2072  	s := strings.Join([]string{`&Bar3{`,
  2073  		`Bars4:` + repeatedStringForBars4 + `,`,
  2074  		`Bars2:` + repeatedStringForBars2 + `,`,
  2075  		`}`,
  2076  	}, "")
  2077  	return s
  2078  }
  2079  func (this *Bar4) String() string {
  2080  	if this == nil {
  2081  		return "nil"
  2082  	}
  2083  	s := strings.Join([]string{`&Bar4{`,
  2084  		`Str:` + fmt.Sprintf("%v", this.Str) + `,`,
  2085  		`}`,
  2086  	}, "")
  2087  	return s
  2088  }
  2089  func (this *Bar5) String() string {
  2090  	if this == nil {
  2091  		return "nil"
  2092  	}
  2093  	repeatedStringForBars2 := "[]*Bar2{"
  2094  	for _, f := range this.Bars2 {
  2095  		repeatedStringForBars2 += strings.Replace(f.String(), "Bar2", "Bar2", 1) + ","
  2096  	}
  2097  	repeatedStringForBars2 += "}"
  2098  	repeatedStringForBars1 := "[]*Bar1{"
  2099  	for _, f := range this.Bars1 {
  2100  		repeatedStringForBars1 += strings.Replace(f.String(), "Bar1", "Bar1", 1) + ","
  2101  	}
  2102  	repeatedStringForBars1 += "}"
  2103  	s := strings.Join([]string{`&Bar5{`,
  2104  		`Bars2:` + repeatedStringForBars2 + `,`,
  2105  		`Bars1:` + repeatedStringForBars1 + `,`,
  2106  		`}`,
  2107  	}, "")
  2108  	return s
  2109  }
  2110  func (this *Bar7) String() string {
  2111  	if this == nil {
  2112  		return "nil"
  2113  	}
  2114  	repeatedStringForBars71 := "[]Bar7{"
  2115  	for _, f := range this.Bars71 {
  2116  		repeatedStringForBars71 += strings.Replace(strings.Replace(f.String(), "Bar7", "Bar7", 1), `&`, ``, 1) + ","
  2117  	}
  2118  	repeatedStringForBars71 += "}"
  2119  	repeatedStringForBars72 := "[]*Bar7{"
  2120  	for _, f := range this.Bars72 {
  2121  		repeatedStringForBars72 += strings.Replace(f.String(), "Bar7", "Bar7", 1) + ","
  2122  	}
  2123  	repeatedStringForBars72 += "}"
  2124  	s := strings.Join([]string{`&Bar7{`,
  2125  		`Bars71:` + repeatedStringForBars71 + `,`,
  2126  		`Bars72:` + repeatedStringForBars72 + `,`,
  2127  		`Str1:` + fmt.Sprintf("%v", this.Str1) + `,`,
  2128  		`Str2:` + valueToStringIssue530(this.Str2) + `,`,
  2129  		`}`,
  2130  	}, "")
  2131  	return s
  2132  }
  2133  func (this *Bar8) String() string {
  2134  	if this == nil {
  2135  		return "nil"
  2136  	}
  2137  	repeatedStringForBars1 := "[]Bar9{"
  2138  	for _, f := range this.Bars1 {
  2139  		repeatedStringForBars1 += fmt.Sprintf("%v", f) + ","
  2140  	}
  2141  	repeatedStringForBars1 += "}"
  2142  	s := strings.Join([]string{`&Bar8{`,
  2143  		`Bars1:` + repeatedStringForBars1 + `,`,
  2144  		`}`,
  2145  	}, "")
  2146  	return s
  2147  }
  2148  func valueToStringIssue530(v interface{}) string {
  2149  	rv := reflect.ValueOf(v)
  2150  	if rv.IsNil() {
  2151  		return "nil"
  2152  	}
  2153  	pv := reflect.Indirect(rv).Interface()
  2154  	return fmt.Sprintf("*%v", pv)
  2155  }
  2156  func (m *Foo5) Unmarshal(dAtA []byte) error {
  2157  	l := len(dAtA)
  2158  	iNdEx := 0
  2159  	for iNdEx < l {
  2160  		preIndex := iNdEx
  2161  		var wire uint64
  2162  		for shift := uint(0); ; shift += 7 {
  2163  			if shift >= 64 {
  2164  				return ErrIntOverflowIssue530
  2165  			}
  2166  			if iNdEx >= l {
  2167  				return io.ErrUnexpectedEOF
  2168  			}
  2169  			b := dAtA[iNdEx]
  2170  			iNdEx++
  2171  			wire |= uint64(b&0x7F) << shift
  2172  			if b < 0x80 {
  2173  				break
  2174  			}
  2175  		}
  2176  		fieldNum := int32(wire >> 3)
  2177  		wireType := int(wire & 0x7)
  2178  		if wireType == 4 {
  2179  			return fmt.Errorf("proto: Foo5: wiretype end group for non-group")
  2180  		}
  2181  		if fieldNum <= 0 {
  2182  			return fmt.Errorf("proto: Foo5: illegal tag %d (wire type %d)", fieldNum, wire)
  2183  		}
  2184  		switch fieldNum {
  2185  		case 1:
  2186  			if wireType != 2 {
  2187  				return fmt.Errorf("proto: wrong wireType = %d for field Bar1", wireType)
  2188  			}
  2189  			var msglen int
  2190  			for shift := uint(0); ; shift += 7 {
  2191  				if shift >= 64 {
  2192  					return ErrIntOverflowIssue530
  2193  				}
  2194  				if iNdEx >= l {
  2195  					return io.ErrUnexpectedEOF
  2196  				}
  2197  				b := dAtA[iNdEx]
  2198  				iNdEx++
  2199  				msglen |= int(b&0x7F) << shift
  2200  				if b < 0x80 {
  2201  					break
  2202  				}
  2203  			}
  2204  			if msglen < 0 {
  2205  				return ErrInvalidLengthIssue530
  2206  			}
  2207  			postIndex := iNdEx + msglen
  2208  			if postIndex < 0 {
  2209  				return ErrInvalidLengthIssue530
  2210  			}
  2211  			if postIndex > l {
  2212  				return io.ErrUnexpectedEOF
  2213  			}
  2214  			if err := m.Bar1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2215  				return err
  2216  			}
  2217  			iNdEx = postIndex
  2218  		case 2:
  2219  			if wireType != 2 {
  2220  				return fmt.Errorf("proto: wrong wireType = %d for field Bar2", wireType)
  2221  			}
  2222  			var msglen int
  2223  			for shift := uint(0); ; shift += 7 {
  2224  				if shift >= 64 {
  2225  					return ErrIntOverflowIssue530
  2226  				}
  2227  				if iNdEx >= l {
  2228  					return io.ErrUnexpectedEOF
  2229  				}
  2230  				b := dAtA[iNdEx]
  2231  				iNdEx++
  2232  				msglen |= int(b&0x7F) << shift
  2233  				if b < 0x80 {
  2234  					break
  2235  				}
  2236  			}
  2237  			if msglen < 0 {
  2238  				return ErrInvalidLengthIssue530
  2239  			}
  2240  			postIndex := iNdEx + msglen
  2241  			if postIndex < 0 {
  2242  				return ErrInvalidLengthIssue530
  2243  			}
  2244  			if postIndex > l {
  2245  				return io.ErrUnexpectedEOF
  2246  			}
  2247  			if m.Bar2 == nil {
  2248  				m.Bar2 = &Bar1{}
  2249  			}
  2250  			if err := m.Bar2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2251  				return err
  2252  			}
  2253  			iNdEx = postIndex
  2254  		case 3:
  2255  			if wireType != 2 {
  2256  				return fmt.Errorf("proto: wrong wireType = %d for field Bar3", wireType)
  2257  			}
  2258  			var msglen int
  2259  			for shift := uint(0); ; shift += 7 {
  2260  				if shift >= 64 {
  2261  					return ErrIntOverflowIssue530
  2262  				}
  2263  				if iNdEx >= l {
  2264  					return io.ErrUnexpectedEOF
  2265  				}
  2266  				b := dAtA[iNdEx]
  2267  				iNdEx++
  2268  				msglen |= int(b&0x7F) << shift
  2269  				if b < 0x80 {
  2270  					break
  2271  				}
  2272  			}
  2273  			if msglen < 0 {
  2274  				return ErrInvalidLengthIssue530
  2275  			}
  2276  			postIndex := iNdEx + msglen
  2277  			if postIndex < 0 {
  2278  				return ErrInvalidLengthIssue530
  2279  			}
  2280  			if postIndex > l {
  2281  				return io.ErrUnexpectedEOF
  2282  			}
  2283  			if err := m.Bar3.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2284  				return err
  2285  			}
  2286  			iNdEx = postIndex
  2287  		case 4:
  2288  			if wireType != 2 {
  2289  				return fmt.Errorf("proto: wrong wireType = %d for field Bar4", wireType)
  2290  			}
  2291  			var msglen int
  2292  			for shift := uint(0); ; shift += 7 {
  2293  				if shift >= 64 {
  2294  					return ErrIntOverflowIssue530
  2295  				}
  2296  				if iNdEx >= l {
  2297  					return io.ErrUnexpectedEOF
  2298  				}
  2299  				b := dAtA[iNdEx]
  2300  				iNdEx++
  2301  				msglen |= int(b&0x7F) << shift
  2302  				if b < 0x80 {
  2303  					break
  2304  				}
  2305  			}
  2306  			if msglen < 0 {
  2307  				return ErrInvalidLengthIssue530
  2308  			}
  2309  			postIndex := iNdEx + msglen
  2310  			if postIndex < 0 {
  2311  				return ErrInvalidLengthIssue530
  2312  			}
  2313  			if postIndex > l {
  2314  				return io.ErrUnexpectedEOF
  2315  			}
  2316  			if m.Bar4 == nil {
  2317  				m.Bar4 = &Bar2{}
  2318  			}
  2319  			if err := m.Bar4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2320  				return err
  2321  			}
  2322  			iNdEx = postIndex
  2323  		case 5:
  2324  			if wireType != 2 {
  2325  				return fmt.Errorf("proto: wrong wireType = %d for field Bars1", wireType)
  2326  			}
  2327  			var msglen int
  2328  			for shift := uint(0); ; shift += 7 {
  2329  				if shift >= 64 {
  2330  					return ErrIntOverflowIssue530
  2331  				}
  2332  				if iNdEx >= l {
  2333  					return io.ErrUnexpectedEOF
  2334  				}
  2335  				b := dAtA[iNdEx]
  2336  				iNdEx++
  2337  				msglen |= int(b&0x7F) << shift
  2338  				if b < 0x80 {
  2339  					break
  2340  				}
  2341  			}
  2342  			if msglen < 0 {
  2343  				return ErrInvalidLengthIssue530
  2344  			}
  2345  			postIndex := iNdEx + msglen
  2346  			if postIndex < 0 {
  2347  				return ErrInvalidLengthIssue530
  2348  			}
  2349  			if postIndex > l {
  2350  				return io.ErrUnexpectedEOF
  2351  			}
  2352  			m.Bars1 = append(m.Bars1, Bar1{})
  2353  			if err := m.Bars1[len(m.Bars1)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2354  				return err
  2355  			}
  2356  			iNdEx = postIndex
  2357  		case 6:
  2358  			if wireType != 2 {
  2359  				return fmt.Errorf("proto: wrong wireType = %d for field Bars2", wireType)
  2360  			}
  2361  			var msglen int
  2362  			for shift := uint(0); ; shift += 7 {
  2363  				if shift >= 64 {
  2364  					return ErrIntOverflowIssue530
  2365  				}
  2366  				if iNdEx >= l {
  2367  					return io.ErrUnexpectedEOF
  2368  				}
  2369  				b := dAtA[iNdEx]
  2370  				iNdEx++
  2371  				msglen |= int(b&0x7F) << shift
  2372  				if b < 0x80 {
  2373  					break
  2374  				}
  2375  			}
  2376  			if msglen < 0 {
  2377  				return ErrInvalidLengthIssue530
  2378  			}
  2379  			postIndex := iNdEx + msglen
  2380  			if postIndex < 0 {
  2381  				return ErrInvalidLengthIssue530
  2382  			}
  2383  			if postIndex > l {
  2384  				return io.ErrUnexpectedEOF
  2385  			}
  2386  			m.Bars2 = append(m.Bars2, &Bar1{})
  2387  			if err := m.Bars2[len(m.Bars2)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2388  				return err
  2389  			}
  2390  			iNdEx = postIndex
  2391  		case 7:
  2392  			if wireType != 2 {
  2393  				return fmt.Errorf("proto: wrong wireType = %d for field Bars3", wireType)
  2394  			}
  2395  			var msglen int
  2396  			for shift := uint(0); ; shift += 7 {
  2397  				if shift >= 64 {
  2398  					return ErrIntOverflowIssue530
  2399  				}
  2400  				if iNdEx >= l {
  2401  					return io.ErrUnexpectedEOF
  2402  				}
  2403  				b := dAtA[iNdEx]
  2404  				iNdEx++
  2405  				msglen |= int(b&0x7F) << shift
  2406  				if b < 0x80 {
  2407  					break
  2408  				}
  2409  			}
  2410  			if msglen < 0 {
  2411  				return ErrInvalidLengthIssue530
  2412  			}
  2413  			postIndex := iNdEx + msglen
  2414  			if postIndex < 0 {
  2415  				return ErrInvalidLengthIssue530
  2416  			}
  2417  			if postIndex > l {
  2418  				return io.ErrUnexpectedEOF
  2419  			}
  2420  			m.Bars3 = append(m.Bars3, Bar2{})
  2421  			if err := m.Bars3[len(m.Bars3)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2422  				return err
  2423  			}
  2424  			iNdEx = postIndex
  2425  		case 8:
  2426  			if wireType != 2 {
  2427  				return fmt.Errorf("proto: wrong wireType = %d for field Bars4", wireType)
  2428  			}
  2429  			var msglen int
  2430  			for shift := uint(0); ; shift += 7 {
  2431  				if shift >= 64 {
  2432  					return ErrIntOverflowIssue530
  2433  				}
  2434  				if iNdEx >= l {
  2435  					return io.ErrUnexpectedEOF
  2436  				}
  2437  				b := dAtA[iNdEx]
  2438  				iNdEx++
  2439  				msglen |= int(b&0x7F) << shift
  2440  				if b < 0x80 {
  2441  					break
  2442  				}
  2443  			}
  2444  			if msglen < 0 {
  2445  				return ErrInvalidLengthIssue530
  2446  			}
  2447  			postIndex := iNdEx + msglen
  2448  			if postIndex < 0 {
  2449  				return ErrInvalidLengthIssue530
  2450  			}
  2451  			if postIndex > l {
  2452  				return io.ErrUnexpectedEOF
  2453  			}
  2454  			m.Bars4 = append(m.Bars4, &Bar2{})
  2455  			if err := m.Bars4[len(m.Bars4)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2456  				return err
  2457  			}
  2458  			iNdEx = postIndex
  2459  		case 9:
  2460  			if wireType != 2 {
  2461  				return fmt.Errorf("proto: wrong wireType = %d for field Barrs1", wireType)
  2462  			}
  2463  			var msglen int
  2464  			for shift := uint(0); ; shift += 7 {
  2465  				if shift >= 64 {
  2466  					return ErrIntOverflowIssue530
  2467  				}
  2468  				if iNdEx >= l {
  2469  					return io.ErrUnexpectedEOF
  2470  				}
  2471  				b := dAtA[iNdEx]
  2472  				iNdEx++
  2473  				msglen |= int(b&0x7F) << shift
  2474  				if b < 0x80 {
  2475  					break
  2476  				}
  2477  			}
  2478  			if msglen < 0 {
  2479  				return ErrInvalidLengthIssue530
  2480  			}
  2481  			postIndex := iNdEx + msglen
  2482  			if postIndex < 0 {
  2483  				return ErrInvalidLengthIssue530
  2484  			}
  2485  			if postIndex > l {
  2486  				return io.ErrUnexpectedEOF
  2487  			}
  2488  			m.Barrs1 = append(m.Barrs1, Bar3{})
  2489  			if err := m.Barrs1[len(m.Barrs1)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2490  				return err
  2491  			}
  2492  			iNdEx = postIndex
  2493  		case 10:
  2494  			if wireType != 2 {
  2495  				return fmt.Errorf("proto: wrong wireType = %d for field Barrs2", wireType)
  2496  			}
  2497  			var msglen int
  2498  			for shift := uint(0); ; shift += 7 {
  2499  				if shift >= 64 {
  2500  					return ErrIntOverflowIssue530
  2501  				}
  2502  				if iNdEx >= l {
  2503  					return io.ErrUnexpectedEOF
  2504  				}
  2505  				b := dAtA[iNdEx]
  2506  				iNdEx++
  2507  				msglen |= int(b&0x7F) << shift
  2508  				if b < 0x80 {
  2509  					break
  2510  				}
  2511  			}
  2512  			if msglen < 0 {
  2513  				return ErrInvalidLengthIssue530
  2514  			}
  2515  			postIndex := iNdEx + msglen
  2516  			if postIndex < 0 {
  2517  				return ErrInvalidLengthIssue530
  2518  			}
  2519  			if postIndex > l {
  2520  				return io.ErrUnexpectedEOF
  2521  			}
  2522  			m.Barrs2 = append(m.Barrs2, Bar5{})
  2523  			if err := m.Barrs2[len(m.Barrs2)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2524  				return err
  2525  			}
  2526  			iNdEx = postIndex
  2527  		case 11:
  2528  			if wireType != 2 {
  2529  				return fmt.Errorf("proto: wrong wireType = %d for field Barmap1", wireType)
  2530  			}
  2531  			var msglen int
  2532  			for shift := uint(0); ; shift += 7 {
  2533  				if shift >= 64 {
  2534  					return ErrIntOverflowIssue530
  2535  				}
  2536  				if iNdEx >= l {
  2537  					return io.ErrUnexpectedEOF
  2538  				}
  2539  				b := dAtA[iNdEx]
  2540  				iNdEx++
  2541  				msglen |= int(b&0x7F) << shift
  2542  				if b < 0x80 {
  2543  					break
  2544  				}
  2545  			}
  2546  			if msglen < 0 {
  2547  				return ErrInvalidLengthIssue530
  2548  			}
  2549  			postIndex := iNdEx + msglen
  2550  			if postIndex < 0 {
  2551  				return ErrInvalidLengthIssue530
  2552  			}
  2553  			if postIndex > l {
  2554  				return io.ErrUnexpectedEOF
  2555  			}
  2556  			if m.Barmap1 == nil {
  2557  				m.Barmap1 = make(map[string]*Bar3)
  2558  			}
  2559  			var mapkey string
  2560  			var mapvalue *Bar3
  2561  			for iNdEx < postIndex {
  2562  				entryPreIndex := iNdEx
  2563  				var wire uint64
  2564  				for shift := uint(0); ; shift += 7 {
  2565  					if shift >= 64 {
  2566  						return ErrIntOverflowIssue530
  2567  					}
  2568  					if iNdEx >= l {
  2569  						return io.ErrUnexpectedEOF
  2570  					}
  2571  					b := dAtA[iNdEx]
  2572  					iNdEx++
  2573  					wire |= uint64(b&0x7F) << shift
  2574  					if b < 0x80 {
  2575  						break
  2576  					}
  2577  				}
  2578  				fieldNum := int32(wire >> 3)
  2579  				if fieldNum == 1 {
  2580  					var stringLenmapkey uint64
  2581  					for shift := uint(0); ; shift += 7 {
  2582  						if shift >= 64 {
  2583  							return ErrIntOverflowIssue530
  2584  						}
  2585  						if iNdEx >= l {
  2586  							return io.ErrUnexpectedEOF
  2587  						}
  2588  						b := dAtA[iNdEx]
  2589  						iNdEx++
  2590  						stringLenmapkey |= uint64(b&0x7F) << shift
  2591  						if b < 0x80 {
  2592  							break
  2593  						}
  2594  					}
  2595  					intStringLenmapkey := int(stringLenmapkey)
  2596  					if intStringLenmapkey < 0 {
  2597  						return ErrInvalidLengthIssue530
  2598  					}
  2599  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  2600  					if postStringIndexmapkey < 0 {
  2601  						return ErrInvalidLengthIssue530
  2602  					}
  2603  					if postStringIndexmapkey > l {
  2604  						return io.ErrUnexpectedEOF
  2605  					}
  2606  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  2607  					iNdEx = postStringIndexmapkey
  2608  				} else if fieldNum == 2 {
  2609  					var mapmsglen int
  2610  					for shift := uint(0); ; shift += 7 {
  2611  						if shift >= 64 {
  2612  							return ErrIntOverflowIssue530
  2613  						}
  2614  						if iNdEx >= l {
  2615  							return io.ErrUnexpectedEOF
  2616  						}
  2617  						b := dAtA[iNdEx]
  2618  						iNdEx++
  2619  						mapmsglen |= int(b&0x7F) << shift
  2620  						if b < 0x80 {
  2621  							break
  2622  						}
  2623  					}
  2624  					if mapmsglen < 0 {
  2625  						return ErrInvalidLengthIssue530
  2626  					}
  2627  					postmsgIndex := iNdEx + mapmsglen
  2628  					if postmsgIndex < 0 {
  2629  						return ErrInvalidLengthIssue530
  2630  					}
  2631  					if postmsgIndex > l {
  2632  						return io.ErrUnexpectedEOF
  2633  					}
  2634  					mapvalue = &Bar3{}
  2635  					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
  2636  						return err
  2637  					}
  2638  					iNdEx = postmsgIndex
  2639  				} else {
  2640  					iNdEx = entryPreIndex
  2641  					skippy, err := skipIssue530(dAtA[iNdEx:])
  2642  					if err != nil {
  2643  						return err
  2644  					}
  2645  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  2646  						return ErrInvalidLengthIssue530
  2647  					}
  2648  					if (iNdEx + skippy) > postIndex {
  2649  						return io.ErrUnexpectedEOF
  2650  					}
  2651  					iNdEx += skippy
  2652  				}
  2653  			}
  2654  			m.Barmap1[mapkey] = mapvalue
  2655  			iNdEx = postIndex
  2656  		case 12:
  2657  			if wireType != 2 {
  2658  				return fmt.Errorf("proto: wrong wireType = %d for field Barmap2", wireType)
  2659  			}
  2660  			var msglen int
  2661  			for shift := uint(0); ; shift += 7 {
  2662  				if shift >= 64 {
  2663  					return ErrIntOverflowIssue530
  2664  				}
  2665  				if iNdEx >= l {
  2666  					return io.ErrUnexpectedEOF
  2667  				}
  2668  				b := dAtA[iNdEx]
  2669  				iNdEx++
  2670  				msglen |= int(b&0x7F) << shift
  2671  				if b < 0x80 {
  2672  					break
  2673  				}
  2674  			}
  2675  			if msglen < 0 {
  2676  				return ErrInvalidLengthIssue530
  2677  			}
  2678  			postIndex := iNdEx + msglen
  2679  			if postIndex < 0 {
  2680  				return ErrInvalidLengthIssue530
  2681  			}
  2682  			if postIndex > l {
  2683  				return io.ErrUnexpectedEOF
  2684  			}
  2685  			if m.Barmap2 == nil {
  2686  				m.Barmap2 = make(map[string]*Bar5)
  2687  			}
  2688  			var mapkey string
  2689  			var mapvalue *Bar5
  2690  			for iNdEx < postIndex {
  2691  				entryPreIndex := iNdEx
  2692  				var wire uint64
  2693  				for shift := uint(0); ; shift += 7 {
  2694  					if shift >= 64 {
  2695  						return ErrIntOverflowIssue530
  2696  					}
  2697  					if iNdEx >= l {
  2698  						return io.ErrUnexpectedEOF
  2699  					}
  2700  					b := dAtA[iNdEx]
  2701  					iNdEx++
  2702  					wire |= uint64(b&0x7F) << shift
  2703  					if b < 0x80 {
  2704  						break
  2705  					}
  2706  				}
  2707  				fieldNum := int32(wire >> 3)
  2708  				if fieldNum == 1 {
  2709  					var stringLenmapkey uint64
  2710  					for shift := uint(0); ; shift += 7 {
  2711  						if shift >= 64 {
  2712  							return ErrIntOverflowIssue530
  2713  						}
  2714  						if iNdEx >= l {
  2715  							return io.ErrUnexpectedEOF
  2716  						}
  2717  						b := dAtA[iNdEx]
  2718  						iNdEx++
  2719  						stringLenmapkey |= uint64(b&0x7F) << shift
  2720  						if b < 0x80 {
  2721  							break
  2722  						}
  2723  					}
  2724  					intStringLenmapkey := int(stringLenmapkey)
  2725  					if intStringLenmapkey < 0 {
  2726  						return ErrInvalidLengthIssue530
  2727  					}
  2728  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  2729  					if postStringIndexmapkey < 0 {
  2730  						return ErrInvalidLengthIssue530
  2731  					}
  2732  					if postStringIndexmapkey > l {
  2733  						return io.ErrUnexpectedEOF
  2734  					}
  2735  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  2736  					iNdEx = postStringIndexmapkey
  2737  				} else if fieldNum == 2 {
  2738  					var mapmsglen int
  2739  					for shift := uint(0); ; shift += 7 {
  2740  						if shift >= 64 {
  2741  							return ErrIntOverflowIssue530
  2742  						}
  2743  						if iNdEx >= l {
  2744  							return io.ErrUnexpectedEOF
  2745  						}
  2746  						b := dAtA[iNdEx]
  2747  						iNdEx++
  2748  						mapmsglen |= int(b&0x7F) << shift
  2749  						if b < 0x80 {
  2750  							break
  2751  						}
  2752  					}
  2753  					if mapmsglen < 0 {
  2754  						return ErrInvalidLengthIssue530
  2755  					}
  2756  					postmsgIndex := iNdEx + mapmsglen
  2757  					if postmsgIndex < 0 {
  2758  						return ErrInvalidLengthIssue530
  2759  					}
  2760  					if postmsgIndex > l {
  2761  						return io.ErrUnexpectedEOF
  2762  					}
  2763  					mapvalue = &Bar5{}
  2764  					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
  2765  						return err
  2766  					}
  2767  					iNdEx = postmsgIndex
  2768  				} else {
  2769  					iNdEx = entryPreIndex
  2770  					skippy, err := skipIssue530(dAtA[iNdEx:])
  2771  					if err != nil {
  2772  						return err
  2773  					}
  2774  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  2775  						return ErrInvalidLengthIssue530
  2776  					}
  2777  					if (iNdEx + skippy) > postIndex {
  2778  						return io.ErrUnexpectedEOF
  2779  					}
  2780  					iNdEx += skippy
  2781  				}
  2782  			}
  2783  			m.Barmap2[mapkey] = mapvalue
  2784  			iNdEx = postIndex
  2785  		default:
  2786  			iNdEx = preIndex
  2787  			skippy, err := skipIssue530(dAtA[iNdEx:])
  2788  			if err != nil {
  2789  				return err
  2790  			}
  2791  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2792  				return ErrInvalidLengthIssue530
  2793  			}
  2794  			if (iNdEx + skippy) > l {
  2795  				return io.ErrUnexpectedEOF
  2796  			}
  2797  			iNdEx += skippy
  2798  		}
  2799  	}
  2800  
  2801  	if iNdEx > l {
  2802  		return io.ErrUnexpectedEOF
  2803  	}
  2804  	return nil
  2805  }
  2806  func (m *Bar1) Unmarshal(dAtA []byte) error {
  2807  	l := len(dAtA)
  2808  	iNdEx := 0
  2809  	for iNdEx < l {
  2810  		preIndex := iNdEx
  2811  		var wire uint64
  2812  		for shift := uint(0); ; shift += 7 {
  2813  			if shift >= 64 {
  2814  				return ErrIntOverflowIssue530
  2815  			}
  2816  			if iNdEx >= l {
  2817  				return io.ErrUnexpectedEOF
  2818  			}
  2819  			b := dAtA[iNdEx]
  2820  			iNdEx++
  2821  			wire |= uint64(b&0x7F) << shift
  2822  			if b < 0x80 {
  2823  				break
  2824  			}
  2825  		}
  2826  		fieldNum := int32(wire >> 3)
  2827  		wireType := int(wire & 0x7)
  2828  		if wireType == 4 {
  2829  			return fmt.Errorf("proto: Bar1: wiretype end group for non-group")
  2830  		}
  2831  		if fieldNum <= 0 {
  2832  			return fmt.Errorf("proto: Bar1: illegal tag %d (wire type %d)", fieldNum, wire)
  2833  		}
  2834  		switch fieldNum {
  2835  		case 1:
  2836  			if wireType != 2 {
  2837  				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
  2838  			}
  2839  			var stringLen uint64
  2840  			for shift := uint(0); ; shift += 7 {
  2841  				if shift >= 64 {
  2842  					return ErrIntOverflowIssue530
  2843  				}
  2844  				if iNdEx >= l {
  2845  					return io.ErrUnexpectedEOF
  2846  				}
  2847  				b := dAtA[iNdEx]
  2848  				iNdEx++
  2849  				stringLen |= uint64(b&0x7F) << shift
  2850  				if b < 0x80 {
  2851  					break
  2852  				}
  2853  			}
  2854  			intStringLen := int(stringLen)
  2855  			if intStringLen < 0 {
  2856  				return ErrInvalidLengthIssue530
  2857  			}
  2858  			postIndex := iNdEx + intStringLen
  2859  			if postIndex < 0 {
  2860  				return ErrInvalidLengthIssue530
  2861  			}
  2862  			if postIndex > l {
  2863  				return io.ErrUnexpectedEOF
  2864  			}
  2865  			m.Str = string(dAtA[iNdEx:postIndex])
  2866  			iNdEx = postIndex
  2867  		default:
  2868  			iNdEx = preIndex
  2869  			skippy, err := skipIssue530(dAtA[iNdEx:])
  2870  			if err != nil {
  2871  				return err
  2872  			}
  2873  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2874  				return ErrInvalidLengthIssue530
  2875  			}
  2876  			if (iNdEx + skippy) > l {
  2877  				return io.ErrUnexpectedEOF
  2878  			}
  2879  			iNdEx += skippy
  2880  		}
  2881  	}
  2882  
  2883  	if iNdEx > l {
  2884  		return io.ErrUnexpectedEOF
  2885  	}
  2886  	return nil
  2887  }
  2888  func (m *Bar2) Unmarshal(dAtA []byte) error {
  2889  	l := len(dAtA)
  2890  	iNdEx := 0
  2891  	for iNdEx < l {
  2892  		preIndex := iNdEx
  2893  		var wire uint64
  2894  		for shift := uint(0); ; shift += 7 {
  2895  			if shift >= 64 {
  2896  				return ErrIntOverflowIssue530
  2897  			}
  2898  			if iNdEx >= l {
  2899  				return io.ErrUnexpectedEOF
  2900  			}
  2901  			b := dAtA[iNdEx]
  2902  			iNdEx++
  2903  			wire |= uint64(b&0x7F) << shift
  2904  			if b < 0x80 {
  2905  				break
  2906  			}
  2907  		}
  2908  		fieldNum := int32(wire >> 3)
  2909  		wireType := int(wire & 0x7)
  2910  		if wireType == 4 {
  2911  			return fmt.Errorf("proto: Bar2: wiretype end group for non-group")
  2912  		}
  2913  		if fieldNum <= 0 {
  2914  			return fmt.Errorf("proto: Bar2: illegal tag %d (wire type %d)", fieldNum, wire)
  2915  		}
  2916  		switch fieldNum {
  2917  		case 1:
  2918  			if wireType != 2 {
  2919  				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
  2920  			}
  2921  			var stringLen uint64
  2922  			for shift := uint(0); ; shift += 7 {
  2923  				if shift >= 64 {
  2924  					return ErrIntOverflowIssue530
  2925  				}
  2926  				if iNdEx >= l {
  2927  					return io.ErrUnexpectedEOF
  2928  				}
  2929  				b := dAtA[iNdEx]
  2930  				iNdEx++
  2931  				stringLen |= uint64(b&0x7F) << shift
  2932  				if b < 0x80 {
  2933  					break
  2934  				}
  2935  			}
  2936  			intStringLen := int(stringLen)
  2937  			if intStringLen < 0 {
  2938  				return ErrInvalidLengthIssue530
  2939  			}
  2940  			postIndex := iNdEx + intStringLen
  2941  			if postIndex < 0 {
  2942  				return ErrInvalidLengthIssue530
  2943  			}
  2944  			if postIndex > l {
  2945  				return io.ErrUnexpectedEOF
  2946  			}
  2947  			s := string(dAtA[iNdEx:postIndex])
  2948  			m.Str = &s
  2949  			iNdEx = postIndex
  2950  		default:
  2951  			iNdEx = preIndex
  2952  			skippy, err := skipIssue530(dAtA[iNdEx:])
  2953  			if err != nil {
  2954  				return err
  2955  			}
  2956  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2957  				return ErrInvalidLengthIssue530
  2958  			}
  2959  			if (iNdEx + skippy) > l {
  2960  				return io.ErrUnexpectedEOF
  2961  			}
  2962  			iNdEx += skippy
  2963  		}
  2964  	}
  2965  
  2966  	if iNdEx > l {
  2967  		return io.ErrUnexpectedEOF
  2968  	}
  2969  	return nil
  2970  }
  2971  func (m *Bar3) Unmarshal(dAtA []byte) error {
  2972  	l := len(dAtA)
  2973  	iNdEx := 0
  2974  	for iNdEx < l {
  2975  		preIndex := iNdEx
  2976  		var wire uint64
  2977  		for shift := uint(0); ; shift += 7 {
  2978  			if shift >= 64 {
  2979  				return ErrIntOverflowIssue530
  2980  			}
  2981  			if iNdEx >= l {
  2982  				return io.ErrUnexpectedEOF
  2983  			}
  2984  			b := dAtA[iNdEx]
  2985  			iNdEx++
  2986  			wire |= uint64(b&0x7F) << shift
  2987  			if b < 0x80 {
  2988  				break
  2989  			}
  2990  		}
  2991  		fieldNum := int32(wire >> 3)
  2992  		wireType := int(wire & 0x7)
  2993  		if wireType == 4 {
  2994  			return fmt.Errorf("proto: Bar3: wiretype end group for non-group")
  2995  		}
  2996  		if fieldNum <= 0 {
  2997  			return fmt.Errorf("proto: Bar3: illegal tag %d (wire type %d)", fieldNum, wire)
  2998  		}
  2999  		switch fieldNum {
  3000  		case 1:
  3001  			if wireType != 2 {
  3002  				return fmt.Errorf("proto: wrong wireType = %d for field Bars4", wireType)
  3003  			}
  3004  			var msglen int
  3005  			for shift := uint(0); ; shift += 7 {
  3006  				if shift >= 64 {
  3007  					return ErrIntOverflowIssue530
  3008  				}
  3009  				if iNdEx >= l {
  3010  					return io.ErrUnexpectedEOF
  3011  				}
  3012  				b := dAtA[iNdEx]
  3013  				iNdEx++
  3014  				msglen |= int(b&0x7F) << shift
  3015  				if b < 0x80 {
  3016  					break
  3017  				}
  3018  			}
  3019  			if msglen < 0 {
  3020  				return ErrInvalidLengthIssue530
  3021  			}
  3022  			postIndex := iNdEx + msglen
  3023  			if postIndex < 0 {
  3024  				return ErrInvalidLengthIssue530
  3025  			}
  3026  			if postIndex > l {
  3027  				return io.ErrUnexpectedEOF
  3028  			}
  3029  			m.Bars4 = append(m.Bars4, Bar4{})
  3030  			if err := m.Bars4[len(m.Bars4)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3031  				return err
  3032  			}
  3033  			iNdEx = postIndex
  3034  		case 2:
  3035  			if wireType != 2 {
  3036  				return fmt.Errorf("proto: wrong wireType = %d for field Bars2", wireType)
  3037  			}
  3038  			var msglen int
  3039  			for shift := uint(0); ; shift += 7 {
  3040  				if shift >= 64 {
  3041  					return ErrIntOverflowIssue530
  3042  				}
  3043  				if iNdEx >= l {
  3044  					return io.ErrUnexpectedEOF
  3045  				}
  3046  				b := dAtA[iNdEx]
  3047  				iNdEx++
  3048  				msglen |= int(b&0x7F) << shift
  3049  				if b < 0x80 {
  3050  					break
  3051  				}
  3052  			}
  3053  			if msglen < 0 {
  3054  				return ErrInvalidLengthIssue530
  3055  			}
  3056  			postIndex := iNdEx + msglen
  3057  			if postIndex < 0 {
  3058  				return ErrInvalidLengthIssue530
  3059  			}
  3060  			if postIndex > l {
  3061  				return io.ErrUnexpectedEOF
  3062  			}
  3063  			m.Bars2 = append(m.Bars2, Bar2{})
  3064  			if err := m.Bars2[len(m.Bars2)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3065  				return err
  3066  			}
  3067  			iNdEx = postIndex
  3068  		default:
  3069  			iNdEx = preIndex
  3070  			skippy, err := skipIssue530(dAtA[iNdEx:])
  3071  			if err != nil {
  3072  				return err
  3073  			}
  3074  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3075  				return ErrInvalidLengthIssue530
  3076  			}
  3077  			if (iNdEx + skippy) > l {
  3078  				return io.ErrUnexpectedEOF
  3079  			}
  3080  			iNdEx += skippy
  3081  		}
  3082  	}
  3083  
  3084  	if iNdEx > l {
  3085  		return io.ErrUnexpectedEOF
  3086  	}
  3087  	return nil
  3088  }
  3089  func (m *Bar4) Unmarshal(dAtA []byte) error {
  3090  	l := len(dAtA)
  3091  	iNdEx := 0
  3092  	for iNdEx < l {
  3093  		preIndex := iNdEx
  3094  		var wire uint64
  3095  		for shift := uint(0); ; shift += 7 {
  3096  			if shift >= 64 {
  3097  				return ErrIntOverflowIssue530
  3098  			}
  3099  			if iNdEx >= l {
  3100  				return io.ErrUnexpectedEOF
  3101  			}
  3102  			b := dAtA[iNdEx]
  3103  			iNdEx++
  3104  			wire |= uint64(b&0x7F) << shift
  3105  			if b < 0x80 {
  3106  				break
  3107  			}
  3108  		}
  3109  		fieldNum := int32(wire >> 3)
  3110  		wireType := int(wire & 0x7)
  3111  		if wireType == 4 {
  3112  			return fmt.Errorf("proto: Bar4: wiretype end group for non-group")
  3113  		}
  3114  		if fieldNum <= 0 {
  3115  			return fmt.Errorf("proto: Bar4: illegal tag %d (wire type %d)", fieldNum, wire)
  3116  		}
  3117  		switch fieldNum {
  3118  		case 1:
  3119  			if wireType != 2 {
  3120  				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
  3121  			}
  3122  			var stringLen uint64
  3123  			for shift := uint(0); ; shift += 7 {
  3124  				if shift >= 64 {
  3125  					return ErrIntOverflowIssue530
  3126  				}
  3127  				if iNdEx >= l {
  3128  					return io.ErrUnexpectedEOF
  3129  				}
  3130  				b := dAtA[iNdEx]
  3131  				iNdEx++
  3132  				stringLen |= uint64(b&0x7F) << shift
  3133  				if b < 0x80 {
  3134  					break
  3135  				}
  3136  			}
  3137  			intStringLen := int(stringLen)
  3138  			if intStringLen < 0 {
  3139  				return ErrInvalidLengthIssue530
  3140  			}
  3141  			postIndex := iNdEx + intStringLen
  3142  			if postIndex < 0 {
  3143  				return ErrInvalidLengthIssue530
  3144  			}
  3145  			if postIndex > l {
  3146  				return io.ErrUnexpectedEOF
  3147  			}
  3148  			m.Str = string(dAtA[iNdEx:postIndex])
  3149  			iNdEx = postIndex
  3150  		default:
  3151  			iNdEx = preIndex
  3152  			skippy, err := skipIssue530(dAtA[iNdEx:])
  3153  			if err != nil {
  3154  				return err
  3155  			}
  3156  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3157  				return ErrInvalidLengthIssue530
  3158  			}
  3159  			if (iNdEx + skippy) > l {
  3160  				return io.ErrUnexpectedEOF
  3161  			}
  3162  			iNdEx += skippy
  3163  		}
  3164  	}
  3165  
  3166  	if iNdEx > l {
  3167  		return io.ErrUnexpectedEOF
  3168  	}
  3169  	return nil
  3170  }
  3171  func (m *Bar5) Unmarshal(dAtA []byte) error {
  3172  	l := len(dAtA)
  3173  	iNdEx := 0
  3174  	for iNdEx < l {
  3175  		preIndex := iNdEx
  3176  		var wire uint64
  3177  		for shift := uint(0); ; shift += 7 {
  3178  			if shift >= 64 {
  3179  				return ErrIntOverflowIssue530
  3180  			}
  3181  			if iNdEx >= l {
  3182  				return io.ErrUnexpectedEOF
  3183  			}
  3184  			b := dAtA[iNdEx]
  3185  			iNdEx++
  3186  			wire |= uint64(b&0x7F) << shift
  3187  			if b < 0x80 {
  3188  				break
  3189  			}
  3190  		}
  3191  		fieldNum := int32(wire >> 3)
  3192  		wireType := int(wire & 0x7)
  3193  		if wireType == 4 {
  3194  			return fmt.Errorf("proto: Bar5: wiretype end group for non-group")
  3195  		}
  3196  		if fieldNum <= 0 {
  3197  			return fmt.Errorf("proto: Bar5: illegal tag %d (wire type %d)", fieldNum, wire)
  3198  		}
  3199  		switch fieldNum {
  3200  		case 1:
  3201  			if wireType != 2 {
  3202  				return fmt.Errorf("proto: wrong wireType = %d for field Bars2", wireType)
  3203  			}
  3204  			var msglen int
  3205  			for shift := uint(0); ; shift += 7 {
  3206  				if shift >= 64 {
  3207  					return ErrIntOverflowIssue530
  3208  				}
  3209  				if iNdEx >= l {
  3210  					return io.ErrUnexpectedEOF
  3211  				}
  3212  				b := dAtA[iNdEx]
  3213  				iNdEx++
  3214  				msglen |= int(b&0x7F) << shift
  3215  				if b < 0x80 {
  3216  					break
  3217  				}
  3218  			}
  3219  			if msglen < 0 {
  3220  				return ErrInvalidLengthIssue530
  3221  			}
  3222  			postIndex := iNdEx + msglen
  3223  			if postIndex < 0 {
  3224  				return ErrInvalidLengthIssue530
  3225  			}
  3226  			if postIndex > l {
  3227  				return io.ErrUnexpectedEOF
  3228  			}
  3229  			m.Bars2 = append(m.Bars2, &Bar2{})
  3230  			if err := m.Bars2[len(m.Bars2)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3231  				return err
  3232  			}
  3233  			iNdEx = postIndex
  3234  		case 2:
  3235  			if wireType != 2 {
  3236  				return fmt.Errorf("proto: wrong wireType = %d for field Bars1", wireType)
  3237  			}
  3238  			var msglen int
  3239  			for shift := uint(0); ; shift += 7 {
  3240  				if shift >= 64 {
  3241  					return ErrIntOverflowIssue530
  3242  				}
  3243  				if iNdEx >= l {
  3244  					return io.ErrUnexpectedEOF
  3245  				}
  3246  				b := dAtA[iNdEx]
  3247  				iNdEx++
  3248  				msglen |= int(b&0x7F) << shift
  3249  				if b < 0x80 {
  3250  					break
  3251  				}
  3252  			}
  3253  			if msglen < 0 {
  3254  				return ErrInvalidLengthIssue530
  3255  			}
  3256  			postIndex := iNdEx + msglen
  3257  			if postIndex < 0 {
  3258  				return ErrInvalidLengthIssue530
  3259  			}
  3260  			if postIndex > l {
  3261  				return io.ErrUnexpectedEOF
  3262  			}
  3263  			m.Bars1 = append(m.Bars1, &Bar1{})
  3264  			if err := m.Bars1[len(m.Bars1)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3265  				return err
  3266  			}
  3267  			iNdEx = postIndex
  3268  		default:
  3269  			iNdEx = preIndex
  3270  			skippy, err := skipIssue530(dAtA[iNdEx:])
  3271  			if err != nil {
  3272  				return err
  3273  			}
  3274  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3275  				return ErrInvalidLengthIssue530
  3276  			}
  3277  			if (iNdEx + skippy) > l {
  3278  				return io.ErrUnexpectedEOF
  3279  			}
  3280  			iNdEx += skippy
  3281  		}
  3282  	}
  3283  
  3284  	if iNdEx > l {
  3285  		return io.ErrUnexpectedEOF
  3286  	}
  3287  	return nil
  3288  }
  3289  func (m *Bar7) Unmarshal(dAtA []byte) error {
  3290  	l := len(dAtA)
  3291  	iNdEx := 0
  3292  	for iNdEx < l {
  3293  		preIndex := iNdEx
  3294  		var wire uint64
  3295  		for shift := uint(0); ; shift += 7 {
  3296  			if shift >= 64 {
  3297  				return ErrIntOverflowIssue530
  3298  			}
  3299  			if iNdEx >= l {
  3300  				return io.ErrUnexpectedEOF
  3301  			}
  3302  			b := dAtA[iNdEx]
  3303  			iNdEx++
  3304  			wire |= uint64(b&0x7F) << shift
  3305  			if b < 0x80 {
  3306  				break
  3307  			}
  3308  		}
  3309  		fieldNum := int32(wire >> 3)
  3310  		wireType := int(wire & 0x7)
  3311  		if wireType == 4 {
  3312  			return fmt.Errorf("proto: Bar7: wiretype end group for non-group")
  3313  		}
  3314  		if fieldNum <= 0 {
  3315  			return fmt.Errorf("proto: Bar7: illegal tag %d (wire type %d)", fieldNum, wire)
  3316  		}
  3317  		switch fieldNum {
  3318  		case 1:
  3319  			if wireType != 2 {
  3320  				return fmt.Errorf("proto: wrong wireType = %d for field Bars71", wireType)
  3321  			}
  3322  			var msglen int
  3323  			for shift := uint(0); ; shift += 7 {
  3324  				if shift >= 64 {
  3325  					return ErrIntOverflowIssue530
  3326  				}
  3327  				if iNdEx >= l {
  3328  					return io.ErrUnexpectedEOF
  3329  				}
  3330  				b := dAtA[iNdEx]
  3331  				iNdEx++
  3332  				msglen |= int(b&0x7F) << shift
  3333  				if b < 0x80 {
  3334  					break
  3335  				}
  3336  			}
  3337  			if msglen < 0 {
  3338  				return ErrInvalidLengthIssue530
  3339  			}
  3340  			postIndex := iNdEx + msglen
  3341  			if postIndex < 0 {
  3342  				return ErrInvalidLengthIssue530
  3343  			}
  3344  			if postIndex > l {
  3345  				return io.ErrUnexpectedEOF
  3346  			}
  3347  			m.Bars71 = append(m.Bars71, Bar7{})
  3348  			if err := m.Bars71[len(m.Bars71)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3349  				return err
  3350  			}
  3351  			iNdEx = postIndex
  3352  		case 2:
  3353  			if wireType != 2 {
  3354  				return fmt.Errorf("proto: wrong wireType = %d for field Bars72", wireType)
  3355  			}
  3356  			var msglen int
  3357  			for shift := uint(0); ; shift += 7 {
  3358  				if shift >= 64 {
  3359  					return ErrIntOverflowIssue530
  3360  				}
  3361  				if iNdEx >= l {
  3362  					return io.ErrUnexpectedEOF
  3363  				}
  3364  				b := dAtA[iNdEx]
  3365  				iNdEx++
  3366  				msglen |= int(b&0x7F) << shift
  3367  				if b < 0x80 {
  3368  					break
  3369  				}
  3370  			}
  3371  			if msglen < 0 {
  3372  				return ErrInvalidLengthIssue530
  3373  			}
  3374  			postIndex := iNdEx + msglen
  3375  			if postIndex < 0 {
  3376  				return ErrInvalidLengthIssue530
  3377  			}
  3378  			if postIndex > l {
  3379  				return io.ErrUnexpectedEOF
  3380  			}
  3381  			m.Bars72 = append(m.Bars72, &Bar7{})
  3382  			if err := m.Bars72[len(m.Bars72)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3383  				return err
  3384  			}
  3385  			iNdEx = postIndex
  3386  		case 3:
  3387  			if wireType != 2 {
  3388  				return fmt.Errorf("proto: wrong wireType = %d for field Str1", wireType)
  3389  			}
  3390  			var stringLen uint64
  3391  			for shift := uint(0); ; shift += 7 {
  3392  				if shift >= 64 {
  3393  					return ErrIntOverflowIssue530
  3394  				}
  3395  				if iNdEx >= l {
  3396  					return io.ErrUnexpectedEOF
  3397  				}
  3398  				b := dAtA[iNdEx]
  3399  				iNdEx++
  3400  				stringLen |= uint64(b&0x7F) << shift
  3401  				if b < 0x80 {
  3402  					break
  3403  				}
  3404  			}
  3405  			intStringLen := int(stringLen)
  3406  			if intStringLen < 0 {
  3407  				return ErrInvalidLengthIssue530
  3408  			}
  3409  			postIndex := iNdEx + intStringLen
  3410  			if postIndex < 0 {
  3411  				return ErrInvalidLengthIssue530
  3412  			}
  3413  			if postIndex > l {
  3414  				return io.ErrUnexpectedEOF
  3415  			}
  3416  			m.Str1 = string(dAtA[iNdEx:postIndex])
  3417  			iNdEx = postIndex
  3418  		case 4:
  3419  			if wireType != 2 {
  3420  				return fmt.Errorf("proto: wrong wireType = %d for field Str2", wireType)
  3421  			}
  3422  			var stringLen uint64
  3423  			for shift := uint(0); ; shift += 7 {
  3424  				if shift >= 64 {
  3425  					return ErrIntOverflowIssue530
  3426  				}
  3427  				if iNdEx >= l {
  3428  					return io.ErrUnexpectedEOF
  3429  				}
  3430  				b := dAtA[iNdEx]
  3431  				iNdEx++
  3432  				stringLen |= uint64(b&0x7F) << shift
  3433  				if b < 0x80 {
  3434  					break
  3435  				}
  3436  			}
  3437  			intStringLen := int(stringLen)
  3438  			if intStringLen < 0 {
  3439  				return ErrInvalidLengthIssue530
  3440  			}
  3441  			postIndex := iNdEx + intStringLen
  3442  			if postIndex < 0 {
  3443  				return ErrInvalidLengthIssue530
  3444  			}
  3445  			if postIndex > l {
  3446  				return io.ErrUnexpectedEOF
  3447  			}
  3448  			s := string(dAtA[iNdEx:postIndex])
  3449  			m.Str2 = &s
  3450  			iNdEx = postIndex
  3451  		default:
  3452  			iNdEx = preIndex
  3453  			skippy, err := skipIssue530(dAtA[iNdEx:])
  3454  			if err != nil {
  3455  				return err
  3456  			}
  3457  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3458  				return ErrInvalidLengthIssue530
  3459  			}
  3460  			if (iNdEx + skippy) > l {
  3461  				return io.ErrUnexpectedEOF
  3462  			}
  3463  			iNdEx += skippy
  3464  		}
  3465  	}
  3466  
  3467  	if iNdEx > l {
  3468  		return io.ErrUnexpectedEOF
  3469  	}
  3470  	return nil
  3471  }
  3472  func (m *Bar8) Unmarshal(dAtA []byte) error {
  3473  	l := len(dAtA)
  3474  	iNdEx := 0
  3475  	for iNdEx < l {
  3476  		preIndex := iNdEx
  3477  		var wire uint64
  3478  		for shift := uint(0); ; shift += 7 {
  3479  			if shift >= 64 {
  3480  				return ErrIntOverflowIssue530
  3481  			}
  3482  			if iNdEx >= l {
  3483  				return io.ErrUnexpectedEOF
  3484  			}
  3485  			b := dAtA[iNdEx]
  3486  			iNdEx++
  3487  			wire |= uint64(b&0x7F) << shift
  3488  			if b < 0x80 {
  3489  				break
  3490  			}
  3491  		}
  3492  		fieldNum := int32(wire >> 3)
  3493  		wireType := int(wire & 0x7)
  3494  		if wireType == 4 {
  3495  			return fmt.Errorf("proto: Bar8: wiretype end group for non-group")
  3496  		}
  3497  		if fieldNum <= 0 {
  3498  			return fmt.Errorf("proto: Bar8: illegal tag %d (wire type %d)", fieldNum, wire)
  3499  		}
  3500  		switch fieldNum {
  3501  		case 1:
  3502  			if wireType != 2 {
  3503  				return fmt.Errorf("proto: wrong wireType = %d for field Bars1", wireType)
  3504  			}
  3505  			var msglen int
  3506  			for shift := uint(0); ; shift += 7 {
  3507  				if shift >= 64 {
  3508  					return ErrIntOverflowIssue530
  3509  				}
  3510  				if iNdEx >= l {
  3511  					return io.ErrUnexpectedEOF
  3512  				}
  3513  				b := dAtA[iNdEx]
  3514  				iNdEx++
  3515  				msglen |= int(b&0x7F) << shift
  3516  				if b < 0x80 {
  3517  					break
  3518  				}
  3519  			}
  3520  			if msglen < 0 {
  3521  				return ErrInvalidLengthIssue530
  3522  			}
  3523  			postIndex := iNdEx + msglen
  3524  			if postIndex < 0 {
  3525  				return ErrInvalidLengthIssue530
  3526  			}
  3527  			if postIndex > l {
  3528  				return io.ErrUnexpectedEOF
  3529  			}
  3530  			m.Bars1 = append(m.Bars1, Bar9{})
  3531  			if err := m.Bars1[len(m.Bars1)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3532  				return err
  3533  			}
  3534  			iNdEx = postIndex
  3535  		default:
  3536  			iNdEx = preIndex
  3537  			skippy, err := skipIssue530(dAtA[iNdEx:])
  3538  			if err != nil {
  3539  				return err
  3540  			}
  3541  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3542  				return ErrInvalidLengthIssue530
  3543  			}
  3544  			if (iNdEx + skippy) > l {
  3545  				return io.ErrUnexpectedEOF
  3546  			}
  3547  			iNdEx += skippy
  3548  		}
  3549  	}
  3550  
  3551  	if iNdEx > l {
  3552  		return io.ErrUnexpectedEOF
  3553  	}
  3554  	return nil
  3555  }
  3556  func (m *Bar9) Unmarshal(dAtA []byte) error {
  3557  	l := len(dAtA)
  3558  	iNdEx := 0
  3559  	for iNdEx < l {
  3560  		preIndex := iNdEx
  3561  		var wire uint64
  3562  		for shift := uint(0); ; shift += 7 {
  3563  			if shift >= 64 {
  3564  				return ErrIntOverflowIssue530
  3565  			}
  3566  			if iNdEx >= l {
  3567  				return io.ErrUnexpectedEOF
  3568  			}
  3569  			b := dAtA[iNdEx]
  3570  			iNdEx++
  3571  			wire |= uint64(b&0x7F) << shift
  3572  			if b < 0x80 {
  3573  				break
  3574  			}
  3575  		}
  3576  		fieldNum := int32(wire >> 3)
  3577  		wireType := int(wire & 0x7)
  3578  		if wireType == 4 {
  3579  			return fmt.Errorf("proto: Bar9: wiretype end group for non-group")
  3580  		}
  3581  		if fieldNum <= 0 {
  3582  			return fmt.Errorf("proto: Bar9: illegal tag %d (wire type %d)", fieldNum, wire)
  3583  		}
  3584  		switch fieldNum {
  3585  		case 1:
  3586  			if wireType != 2 {
  3587  				return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
  3588  			}
  3589  			var stringLen uint64
  3590  			for shift := uint(0); ; shift += 7 {
  3591  				if shift >= 64 {
  3592  					return ErrIntOverflowIssue530
  3593  				}
  3594  				if iNdEx >= l {
  3595  					return io.ErrUnexpectedEOF
  3596  				}
  3597  				b := dAtA[iNdEx]
  3598  				iNdEx++
  3599  				stringLen |= uint64(b&0x7F) << shift
  3600  				if b < 0x80 {
  3601  					break
  3602  				}
  3603  			}
  3604  			intStringLen := int(stringLen)
  3605  			if intStringLen < 0 {
  3606  				return ErrInvalidLengthIssue530
  3607  			}
  3608  			postIndex := iNdEx + intStringLen
  3609  			if postIndex < 0 {
  3610  				return ErrInvalidLengthIssue530
  3611  			}
  3612  			if postIndex > l {
  3613  				return io.ErrUnexpectedEOF
  3614  			}
  3615  			m.Str = string(dAtA[iNdEx:postIndex])
  3616  			iNdEx = postIndex
  3617  		default:
  3618  			iNdEx = preIndex
  3619  			skippy, err := skipIssue530(dAtA[iNdEx:])
  3620  			if err != nil {
  3621  				return err
  3622  			}
  3623  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3624  				return ErrInvalidLengthIssue530
  3625  			}
  3626  			if (iNdEx + skippy) > l {
  3627  				return io.ErrUnexpectedEOF
  3628  			}
  3629  			iNdEx += skippy
  3630  		}
  3631  	}
  3632  
  3633  	if iNdEx > l {
  3634  		return io.ErrUnexpectedEOF
  3635  	}
  3636  	return nil
  3637  }
  3638  func skipIssue530(dAtA []byte) (n int, err error) {
  3639  	l := len(dAtA)
  3640  	iNdEx := 0
  3641  	depth := 0
  3642  	for iNdEx < l {
  3643  		var wire uint64
  3644  		for shift := uint(0); ; shift += 7 {
  3645  			if shift >= 64 {
  3646  				return 0, ErrIntOverflowIssue530
  3647  			}
  3648  			if iNdEx >= l {
  3649  				return 0, io.ErrUnexpectedEOF
  3650  			}
  3651  			b := dAtA[iNdEx]
  3652  			iNdEx++
  3653  			wire |= (uint64(b) & 0x7F) << shift
  3654  			if b < 0x80 {
  3655  				break
  3656  			}
  3657  		}
  3658  		wireType := int(wire & 0x7)
  3659  		switch wireType {
  3660  		case 0:
  3661  			for shift := uint(0); ; shift += 7 {
  3662  				if shift >= 64 {
  3663  					return 0, ErrIntOverflowIssue530
  3664  				}
  3665  				if iNdEx >= l {
  3666  					return 0, io.ErrUnexpectedEOF
  3667  				}
  3668  				iNdEx++
  3669  				if dAtA[iNdEx-1] < 0x80 {
  3670  					break
  3671  				}
  3672  			}
  3673  		case 1:
  3674  			iNdEx += 8
  3675  		case 2:
  3676  			var length int
  3677  			for shift := uint(0); ; shift += 7 {
  3678  				if shift >= 64 {
  3679  					return 0, ErrIntOverflowIssue530
  3680  				}
  3681  				if iNdEx >= l {
  3682  					return 0, io.ErrUnexpectedEOF
  3683  				}
  3684  				b := dAtA[iNdEx]
  3685  				iNdEx++
  3686  				length |= (int(b) & 0x7F) << shift
  3687  				if b < 0x80 {
  3688  					break
  3689  				}
  3690  			}
  3691  			if length < 0 {
  3692  				return 0, ErrInvalidLengthIssue530
  3693  			}
  3694  			iNdEx += length
  3695  		case 3:
  3696  			depth++
  3697  		case 4:
  3698  			if depth == 0 {
  3699  				return 0, ErrUnexpectedEndOfGroupIssue530
  3700  			}
  3701  			depth--
  3702  		case 5:
  3703  			iNdEx += 4
  3704  		default:
  3705  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  3706  		}
  3707  		if iNdEx < 0 {
  3708  			return 0, ErrInvalidLengthIssue530
  3709  		}
  3710  		if depth == 0 {
  3711  			return iNdEx, nil
  3712  		}
  3713  	}
  3714  	return 0, io.ErrUnexpectedEOF
  3715  }
  3716  
  3717  var (
  3718  	ErrInvalidLengthIssue530        = fmt.Errorf("proto: negative length found during unmarshaling")
  3719  	ErrIntOverflowIssue530          = fmt.Errorf("proto: integer overflow")
  3720  	ErrUnexpectedEndOfGroupIssue530 = fmt.Errorf("proto: unexpected end of group")
  3721  )
  3722  

View as plain text