github.com/kiali/kiali@v1.84.0/tracing/tempo/tempopb/common/v1/common.pb.go (about)

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: common/v1/common.proto
     3  
     4  package v1
     5  
     6  import (
     7  	encoding_binary "encoding/binary"
     8  	fmt "fmt"
     9  	proto "github.com/gogo/protobuf/proto"
    10  	io "io"
    11  	math "math"
    12  	math_bits "math/bits"
    13  )
    14  
    15  // Reference imports to suppress errors if they are not otherwise used.
    16  var _ = proto.Marshal
    17  var _ = fmt.Errorf
    18  var _ = math.Inf
    19  
    20  // This is a compile-time assertion to ensure that this generated file
    21  // is compatible with the proto package it is being compiled against.
    22  // A compilation error at this line likely means your copy of the
    23  // proto package needs to be updated.
    24  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    25  
    26  // AnyValue is used to represent any type of attribute value. AnyValue may contain a
    27  // primitive value such as a string or integer or it may contain an arbitrary nested
    28  // object containing arrays, key-value lists and primitives.
    29  type AnyValue struct {
    30  	// The value is one of the listed fields. It is valid for all values to be unspecified
    31  	// in which case this AnyValue is considered to be "empty".
    32  	//
    33  	// Types that are valid to be assigned to Value:
    34  	//	*AnyValue_StringValue
    35  	//	*AnyValue_BoolValue
    36  	//	*AnyValue_IntValue
    37  	//	*AnyValue_DoubleValue
    38  	//	*AnyValue_ArrayValue
    39  	//	*AnyValue_KvlistValue
    40  	//	*AnyValue_BytesValue
    41  	Value isAnyValue_Value `protobuf_oneof:"value"`
    42  }
    43  
    44  func (m *AnyValue) Reset()         { *m = AnyValue{} }
    45  func (m *AnyValue) String() string { return proto.CompactTextString(m) }
    46  func (*AnyValue) ProtoMessage()    {}
    47  func (*AnyValue) Descriptor() ([]byte, []int) {
    48  	return fileDescriptor_92d5df4519b8f2e3, []int{0}
    49  }
    50  func (m *AnyValue) XXX_Unmarshal(b []byte) error {
    51  	return m.Unmarshal(b)
    52  }
    53  func (m *AnyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    54  	if deterministic {
    55  		return xxx_messageInfo_AnyValue.Marshal(b, m, deterministic)
    56  	} else {
    57  		b = b[:cap(b)]
    58  		n, err := m.MarshalToSizedBuffer(b)
    59  		if err != nil {
    60  			return nil, err
    61  		}
    62  		return b[:n], nil
    63  	}
    64  }
    65  func (m *AnyValue) XXX_Merge(src proto.Message) {
    66  	xxx_messageInfo_AnyValue.Merge(m, src)
    67  }
    68  func (m *AnyValue) XXX_Size() int {
    69  	return m.Size()
    70  }
    71  func (m *AnyValue) XXX_DiscardUnknown() {
    72  	xxx_messageInfo_AnyValue.DiscardUnknown(m)
    73  }
    74  
    75  var xxx_messageInfo_AnyValue proto.InternalMessageInfo
    76  
    77  type isAnyValue_Value interface {
    78  	isAnyValue_Value()
    79  	MarshalTo([]byte) (int, error)
    80  	Size() int
    81  }
    82  
    83  type AnyValue_StringValue struct {
    84  	StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
    85  }
    86  type AnyValue_BoolValue struct {
    87  	BoolValue bool `protobuf:"varint,2,opt,name=bool_value,json=boolValue,proto3,oneof" json:"bool_value,omitempty"`
    88  }
    89  type AnyValue_IntValue struct {
    90  	IntValue int64 `protobuf:"varint,3,opt,name=int_value,json=intValue,proto3,oneof" json:"int_value,omitempty"`
    91  }
    92  type AnyValue_DoubleValue struct {
    93  	DoubleValue float64 `protobuf:"fixed64,4,opt,name=double_value,json=doubleValue,proto3,oneof" json:"double_value,omitempty"`
    94  }
    95  type AnyValue_ArrayValue struct {
    96  	ArrayValue *ArrayValue `protobuf:"bytes,5,opt,name=array_value,json=arrayValue,proto3,oneof" json:"array_value,omitempty"`
    97  }
    98  type AnyValue_KvlistValue struct {
    99  	KvlistValue *KeyValueList `protobuf:"bytes,6,opt,name=kvlist_value,json=kvlistValue,proto3,oneof" json:"kvlist_value,omitempty"`
   100  }
   101  type AnyValue_BytesValue struct {
   102  	BytesValue []byte `protobuf:"bytes,7,opt,name=bytes_value,json=bytesValue,proto3,oneof" json:"bytes_value,omitempty"`
   103  }
   104  
   105  func (*AnyValue_StringValue) isAnyValue_Value() {}
   106  func (*AnyValue_BoolValue) isAnyValue_Value()   {}
   107  func (*AnyValue_IntValue) isAnyValue_Value()    {}
   108  func (*AnyValue_DoubleValue) isAnyValue_Value() {}
   109  func (*AnyValue_ArrayValue) isAnyValue_Value()  {}
   110  func (*AnyValue_KvlistValue) isAnyValue_Value() {}
   111  func (*AnyValue_BytesValue) isAnyValue_Value()  {}
   112  
   113  func (m *AnyValue) GetValue() isAnyValue_Value {
   114  	if m != nil {
   115  		return m.Value
   116  	}
   117  	return nil
   118  }
   119  
   120  func (m *AnyValue) GetStringValue() string {
   121  	if x, ok := m.GetValue().(*AnyValue_StringValue); ok {
   122  		return x.StringValue
   123  	}
   124  	return ""
   125  }
   126  
   127  func (m *AnyValue) GetBoolValue() bool {
   128  	if x, ok := m.GetValue().(*AnyValue_BoolValue); ok {
   129  		return x.BoolValue
   130  	}
   131  	return false
   132  }
   133  
   134  func (m *AnyValue) GetIntValue() int64 {
   135  	if x, ok := m.GetValue().(*AnyValue_IntValue); ok {
   136  		return x.IntValue
   137  	}
   138  	return 0
   139  }
   140  
   141  func (m *AnyValue) GetDoubleValue() float64 {
   142  	if x, ok := m.GetValue().(*AnyValue_DoubleValue); ok {
   143  		return x.DoubleValue
   144  	}
   145  	return 0
   146  }
   147  
   148  func (m *AnyValue) GetArrayValue() *ArrayValue {
   149  	if x, ok := m.GetValue().(*AnyValue_ArrayValue); ok {
   150  		return x.ArrayValue
   151  	}
   152  	return nil
   153  }
   154  
   155  func (m *AnyValue) GetKvlistValue() *KeyValueList {
   156  	if x, ok := m.GetValue().(*AnyValue_KvlistValue); ok {
   157  		return x.KvlistValue
   158  	}
   159  	return nil
   160  }
   161  
   162  func (m *AnyValue) GetBytesValue() []byte {
   163  	if x, ok := m.GetValue().(*AnyValue_BytesValue); ok {
   164  		return x.BytesValue
   165  	}
   166  	return nil
   167  }
   168  
   169  // XXX_OneofWrappers is for the internal use of the proto package.
   170  func (*AnyValue) XXX_OneofWrappers() []interface{} {
   171  	return []interface{}{
   172  		(*AnyValue_StringValue)(nil),
   173  		(*AnyValue_BoolValue)(nil),
   174  		(*AnyValue_IntValue)(nil),
   175  		(*AnyValue_DoubleValue)(nil),
   176  		(*AnyValue_ArrayValue)(nil),
   177  		(*AnyValue_KvlistValue)(nil),
   178  		(*AnyValue_BytesValue)(nil),
   179  	}
   180  }
   181  
   182  // ArrayValue is a list of AnyValue messages. We need ArrayValue as a message
   183  // since oneof in AnyValue does not allow repeated fields.
   184  type ArrayValue struct {
   185  	// Array of values. The array may be empty (contain 0 elements).
   186  	Values []*AnyValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
   187  }
   188  
   189  func (m *ArrayValue) Reset()         { *m = ArrayValue{} }
   190  func (m *ArrayValue) String() string { return proto.CompactTextString(m) }
   191  func (*ArrayValue) ProtoMessage()    {}
   192  func (*ArrayValue) Descriptor() ([]byte, []int) {
   193  	return fileDescriptor_92d5df4519b8f2e3, []int{1}
   194  }
   195  func (m *ArrayValue) XXX_Unmarshal(b []byte) error {
   196  	return m.Unmarshal(b)
   197  }
   198  func (m *ArrayValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   199  	if deterministic {
   200  		return xxx_messageInfo_ArrayValue.Marshal(b, m, deterministic)
   201  	} else {
   202  		b = b[:cap(b)]
   203  		n, err := m.MarshalToSizedBuffer(b)
   204  		if err != nil {
   205  			return nil, err
   206  		}
   207  		return b[:n], nil
   208  	}
   209  }
   210  func (m *ArrayValue) XXX_Merge(src proto.Message) {
   211  	xxx_messageInfo_ArrayValue.Merge(m, src)
   212  }
   213  func (m *ArrayValue) XXX_Size() int {
   214  	return m.Size()
   215  }
   216  func (m *ArrayValue) XXX_DiscardUnknown() {
   217  	xxx_messageInfo_ArrayValue.DiscardUnknown(m)
   218  }
   219  
   220  var xxx_messageInfo_ArrayValue proto.InternalMessageInfo
   221  
   222  func (m *ArrayValue) GetValues() []*AnyValue {
   223  	if m != nil {
   224  		return m.Values
   225  	}
   226  	return nil
   227  }
   228  
   229  // KeyValueList is a list of KeyValue messages. We need KeyValueList as a message
   230  // since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need
   231  // a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to
   232  // avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches
   233  // are semantically equivalent.
   234  type KeyValueList struct {
   235  	// A collection of key/value pairs of key-value pairs. The list may be empty (may
   236  	// contain 0 elements).
   237  	// The keys MUST be unique (it is not allowed to have more than one
   238  	// value with the same key).
   239  	Values []*KeyValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
   240  }
   241  
   242  func (m *KeyValueList) Reset()         { *m = KeyValueList{} }
   243  func (m *KeyValueList) String() string { return proto.CompactTextString(m) }
   244  func (*KeyValueList) ProtoMessage()    {}
   245  func (*KeyValueList) Descriptor() ([]byte, []int) {
   246  	return fileDescriptor_92d5df4519b8f2e3, []int{2}
   247  }
   248  func (m *KeyValueList) XXX_Unmarshal(b []byte) error {
   249  	return m.Unmarshal(b)
   250  }
   251  func (m *KeyValueList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   252  	if deterministic {
   253  		return xxx_messageInfo_KeyValueList.Marshal(b, m, deterministic)
   254  	} else {
   255  		b = b[:cap(b)]
   256  		n, err := m.MarshalToSizedBuffer(b)
   257  		if err != nil {
   258  			return nil, err
   259  		}
   260  		return b[:n], nil
   261  	}
   262  }
   263  func (m *KeyValueList) XXX_Merge(src proto.Message) {
   264  	xxx_messageInfo_KeyValueList.Merge(m, src)
   265  }
   266  func (m *KeyValueList) XXX_Size() int {
   267  	return m.Size()
   268  }
   269  func (m *KeyValueList) XXX_DiscardUnknown() {
   270  	xxx_messageInfo_KeyValueList.DiscardUnknown(m)
   271  }
   272  
   273  var xxx_messageInfo_KeyValueList proto.InternalMessageInfo
   274  
   275  func (m *KeyValueList) GetValues() []*KeyValue {
   276  	if m != nil {
   277  		return m.Values
   278  	}
   279  	return nil
   280  }
   281  
   282  // KeyValue is a key-value pair that is used to store Span attributes, Link
   283  // attributes, etc.
   284  type KeyValue struct {
   285  	Key   string    `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
   286  	Value *AnyValue `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
   287  }
   288  
   289  func (m *KeyValue) Reset()         { *m = KeyValue{} }
   290  func (m *KeyValue) String() string { return proto.CompactTextString(m) }
   291  func (*KeyValue) ProtoMessage()    {}
   292  func (*KeyValue) Descriptor() ([]byte, []int) {
   293  	return fileDescriptor_92d5df4519b8f2e3, []int{3}
   294  }
   295  func (m *KeyValue) XXX_Unmarshal(b []byte) error {
   296  	return m.Unmarshal(b)
   297  }
   298  func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   299  	if deterministic {
   300  		return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
   301  	} else {
   302  		b = b[:cap(b)]
   303  		n, err := m.MarshalToSizedBuffer(b)
   304  		if err != nil {
   305  			return nil, err
   306  		}
   307  		return b[:n], nil
   308  	}
   309  }
   310  func (m *KeyValue) XXX_Merge(src proto.Message) {
   311  	xxx_messageInfo_KeyValue.Merge(m, src)
   312  }
   313  func (m *KeyValue) XXX_Size() int {
   314  	return m.Size()
   315  }
   316  func (m *KeyValue) XXX_DiscardUnknown() {
   317  	xxx_messageInfo_KeyValue.DiscardUnknown(m)
   318  }
   319  
   320  var xxx_messageInfo_KeyValue proto.InternalMessageInfo
   321  
   322  func (m *KeyValue) GetKey() string {
   323  	if m != nil {
   324  		return m.Key
   325  	}
   326  	return ""
   327  }
   328  
   329  func (m *KeyValue) GetValue() *AnyValue {
   330  	if m != nil {
   331  		return m.Value
   332  	}
   333  	return nil
   334  }
   335  
   336  // InstrumentationLibrary is a message representing the instrumentation library information
   337  // such as the fully qualified name and version.
   338  // InstrumentationLibrary is wire-compatible with InstrumentationScope for binary
   339  // Protobuf format.
   340  // This message is deprecated and will be removed on June 15, 2022.
   341  //
   342  // Deprecated: Do not use.
   343  type InstrumentationLibrary struct {
   344  	// An empty instrumentation library name means the name is unknown.
   345  	Name    string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
   346  	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
   347  }
   348  
   349  func (m *InstrumentationLibrary) Reset()         { *m = InstrumentationLibrary{} }
   350  func (m *InstrumentationLibrary) String() string { return proto.CompactTextString(m) }
   351  func (*InstrumentationLibrary) ProtoMessage()    {}
   352  func (*InstrumentationLibrary) Descriptor() ([]byte, []int) {
   353  	return fileDescriptor_92d5df4519b8f2e3, []int{4}
   354  }
   355  func (m *InstrumentationLibrary) XXX_Unmarshal(b []byte) error {
   356  	return m.Unmarshal(b)
   357  }
   358  func (m *InstrumentationLibrary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   359  	if deterministic {
   360  		return xxx_messageInfo_InstrumentationLibrary.Marshal(b, m, deterministic)
   361  	} else {
   362  		b = b[:cap(b)]
   363  		n, err := m.MarshalToSizedBuffer(b)
   364  		if err != nil {
   365  			return nil, err
   366  		}
   367  		return b[:n], nil
   368  	}
   369  }
   370  func (m *InstrumentationLibrary) XXX_Merge(src proto.Message) {
   371  	xxx_messageInfo_InstrumentationLibrary.Merge(m, src)
   372  }
   373  func (m *InstrumentationLibrary) XXX_Size() int {
   374  	return m.Size()
   375  }
   376  func (m *InstrumentationLibrary) XXX_DiscardUnknown() {
   377  	xxx_messageInfo_InstrumentationLibrary.DiscardUnknown(m)
   378  }
   379  
   380  var xxx_messageInfo_InstrumentationLibrary proto.InternalMessageInfo
   381  
   382  func (m *InstrumentationLibrary) GetName() string {
   383  	if m != nil {
   384  		return m.Name
   385  	}
   386  	return ""
   387  }
   388  
   389  func (m *InstrumentationLibrary) GetVersion() string {
   390  	if m != nil {
   391  		return m.Version
   392  	}
   393  	return ""
   394  }
   395  
   396  // InstrumentationScope is a message representing the instrumentation scope information
   397  // such as the fully qualified name and version.
   398  type InstrumentationScope struct {
   399  	// An empty instrumentation scope name means the name is unknown.
   400  	Name    string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
   401  	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
   402  }
   403  
   404  func (m *InstrumentationScope) Reset()         { *m = InstrumentationScope{} }
   405  func (m *InstrumentationScope) String() string { return proto.CompactTextString(m) }
   406  func (*InstrumentationScope) ProtoMessage()    {}
   407  func (*InstrumentationScope) Descriptor() ([]byte, []int) {
   408  	return fileDescriptor_92d5df4519b8f2e3, []int{5}
   409  }
   410  func (m *InstrumentationScope) XXX_Unmarshal(b []byte) error {
   411  	return m.Unmarshal(b)
   412  }
   413  func (m *InstrumentationScope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   414  	if deterministic {
   415  		return xxx_messageInfo_InstrumentationScope.Marshal(b, m, deterministic)
   416  	} else {
   417  		b = b[:cap(b)]
   418  		n, err := m.MarshalToSizedBuffer(b)
   419  		if err != nil {
   420  			return nil, err
   421  		}
   422  		return b[:n], nil
   423  	}
   424  }
   425  func (m *InstrumentationScope) XXX_Merge(src proto.Message) {
   426  	xxx_messageInfo_InstrumentationScope.Merge(m, src)
   427  }
   428  func (m *InstrumentationScope) XXX_Size() int {
   429  	return m.Size()
   430  }
   431  func (m *InstrumentationScope) XXX_DiscardUnknown() {
   432  	xxx_messageInfo_InstrumentationScope.DiscardUnknown(m)
   433  }
   434  
   435  var xxx_messageInfo_InstrumentationScope proto.InternalMessageInfo
   436  
   437  func (m *InstrumentationScope) GetName() string {
   438  	if m != nil {
   439  		return m.Name
   440  	}
   441  	return ""
   442  }
   443  
   444  func (m *InstrumentationScope) GetVersion() string {
   445  	if m != nil {
   446  		return m.Version
   447  	}
   448  	return ""
   449  }
   450  
   451  func init() {
   452  	proto.RegisterType((*AnyValue)(nil), "tempopb.common.v1.AnyValue")
   453  	proto.RegisterType((*ArrayValue)(nil), "tempopb.common.v1.ArrayValue")
   454  	proto.RegisterType((*KeyValueList)(nil), "tempopb.common.v1.KeyValueList")
   455  	proto.RegisterType((*KeyValue)(nil), "tempopb.common.v1.KeyValue")
   456  	proto.RegisterType((*InstrumentationLibrary)(nil), "tempopb.common.v1.InstrumentationLibrary")
   457  	proto.RegisterType((*InstrumentationScope)(nil), "tempopb.common.v1.InstrumentationScope")
   458  }
   459  
   460  func init() { proto.RegisterFile("common/v1/common.proto", fileDescriptor_92d5df4519b8f2e3) }
   461  
   462  var fileDescriptor_92d5df4519b8f2e3 = []byte{
   463  	// 461 bytes of a gzipped FileDescriptorProto
   464  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x4d, 0x6f, 0x13, 0x31,
   465  	0x10, 0x5d, 0x27, 0x6d, 0x3e, 0x66, 0x73, 0x00, 0x0b, 0x55, 0x91, 0x50, 0xb7, 0x4b, 0xb8, 0xec,
   466  	0x69, 0x57, 0x69, 0x6f, 0x9c, 0x48, 0xda, 0x43, 0x80, 0x4a, 0x54, 0x46, 0xe2, 0xc0, 0x05, 0x79,
   467  	0x8b, 0x09, 0x56, 0x76, 0xed, 0x95, 0xd7, 0x59, 0x69, 0xff, 0x05, 0x3f, 0xab, 0xc7, 0x1e, 0x39,
   468  	0xa2, 0xe4, 0x8f, 0x20, 0x7f, 0x24, 0x45, 0x10, 0x09, 0x7a, 0x9b, 0x79, 0x7e, 0xf3, 0xe6, 0xcd,
   469  	0xd8, 0x86, 0x93, 0x5b, 0x59, 0x96, 0x52, 0x64, 0xcd, 0x34, 0x73, 0x51, 0x5a, 0x29, 0xa9, 0x25,
   470  	0x7e, 0xaa, 0x59, 0x59, 0xc9, 0x2a, 0x4f, 0x3d, 0xda, 0x4c, 0x27, 0x77, 0x1d, 0x18, 0xcc, 0x44,
   471  	0xfb, 0x91, 0x16, 0x6b, 0x86, 0x5f, 0xc2, 0xa8, 0xd6, 0x8a, 0x8b, 0xe5, 0xe7, 0xc6, 0xe4, 0x63,
   472  	0x14, 0xa3, 0x64, 0xb8, 0x08, 0x48, 0xe8, 0x50, 0x47, 0x3a, 0x03, 0xc8, 0xa5, 0x2c, 0x3c, 0xa5,
   473  	0x13, 0xa3, 0x64, 0xb0, 0x08, 0xc8, 0xd0, 0x60, 0x8e, 0x70, 0x0a, 0x43, 0x2e, 0xb4, 0x3f, 0xef,
   474  	0xc6, 0x28, 0xe9, 0x2e, 0x02, 0x32, 0xe0, 0x42, 0xef, 0x9b, 0x7c, 0x91, 0xeb, 0xbc, 0x60, 0x9e,
   475  	0x71, 0x14, 0xa3, 0x04, 0x99, 0x26, 0x0e, 0x75, 0xa4, 0xd7, 0x10, 0x52, 0xa5, 0x68, 0xeb, 0x39,
   476  	0xc7, 0x31, 0x4a, 0xc2, 0xf3, 0xd3, 0xf4, 0x2f, 0xff, 0xe9, 0xcc, 0xb0, 0x6c, 0xcd, 0x22, 0x20,
   477  	0x40, 0xf7, 0x19, 0xbe, 0x82, 0xd1, 0xaa, 0x29, 0x78, 0xbd, 0x33, 0xd2, 0xb3, 0x12, 0x67, 0x07,
   478  	0x24, 0xde, 0x31, 0x57, 0x72, 0xcd, 0x6b, 0x6d, 0x7c, 0xb8, 0x32, 0xa7, 0xf2, 0x02, 0xc2, 0xbc,
   479  	0xd5, 0xac, 0xf6, 0x22, 0xfd, 0x18, 0x25, 0x23, 0xd3, 0xc8, 0x82, 0x96, 0x32, 0xef, 0xc3, 0xb1,
   480  	0x3d, 0x9c, 0xcc, 0x00, 0x1e, 0xdc, 0xe0, 0x0b, 0xe8, 0x59, 0xb8, 0x1e, 0xa3, 0xb8, 0x9b, 0x84,
   481  	0xe7, 0xcf, 0x0f, 0x99, 0xf7, 0x8b, 0x27, 0x9e, 0x3a, 0xb9, 0x84, 0xd1, 0xef, 0x6e, 0xfe, 0x4b,
   482  	0x64, 0x57, 0xb0, 0x17, 0x79, 0x0f, 0x83, 0x1d, 0x86, 0x9f, 0x40, 0x77, 0xc5, 0x5a, 0x77, 0x91,
   483  	0xc4, 0x84, 0x78, 0xea, 0xed, 0xda, 0x9b, 0xfb, 0x87, 0x2d, 0x3f, 0xd8, 0x5b, 0x38, 0x79, 0x23,
   484  	0x6a, 0xad, 0xd6, 0x25, 0x13, 0x9a, 0x6a, 0x2e, 0xc5, 0x35, 0xcf, 0x15, 0x55, 0x2d, 0xc6, 0x70,
   485  	0x24, 0x68, 0xe9, 0x1f, 0x0a, 0xb1, 0x31, 0x1e, 0x43, 0xbf, 0x61, 0xaa, 0xe6, 0x52, 0xd8, 0x16,
   486  	0x43, 0xb2, 0x4b, 0x5f, 0x75, 0xc6, 0x68, 0x72, 0x05, 0xcf, 0xfe, 0xd0, 0xfa, 0x70, 0x2b, 0x2b,
   487  	0xf6, 0x38, 0xa5, 0x79, 0x7b, 0xb7, 0x89, 0xd0, 0xfd, 0x26, 0x42, 0x3f, 0x37, 0x11, 0xfa, 0xbe,
   488  	0x8d, 0x82, 0xfb, 0x6d, 0x14, 0xfc, 0xd8, 0x46, 0x01, 0xc4, 0x5c, 0xa6, 0xb2, 0x62, 0x42, 0xb3,
   489  	0x82, 0x95, 0x4c, 0xab, 0xd6, 0x3d, 0xfd, 0x87, 0xe9, 0xe6, 0xe1, 0xa5, 0x0d, 0x6f, 0x0c, 0x7c,
   490  	0x83, 0x3e, 0xa5, 0x4b, 0xae, 0xbf, 0xad, 0xed, 0xf8, 0xd9, 0x52, 0xd1, 0xaf, 0x54, 0xd0, 0xcc,
   491  	0xae, 0x24, 0xab, 0x56, 0xcb, 0xcc, 0x2f, 0x27, 0xdb, 0x7f, 0xa8, 0xbc, 0x67, 0xf5, 0x2e, 0x7e,
   492  	0x05, 0x00, 0x00, 0xff, 0xff, 0xac, 0x29, 0x78, 0x73, 0x64, 0x03, 0x00, 0x00,
   493  }
   494  
   495  func (m *AnyValue) Marshal() (dAtA []byte, err error) {
   496  	size := m.Size()
   497  	dAtA = make([]byte, size)
   498  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   499  	if err != nil {
   500  		return nil, err
   501  	}
   502  	return dAtA[:n], nil
   503  }
   504  
   505  func (m *AnyValue) MarshalTo(dAtA []byte) (int, error) {
   506  	size := m.Size()
   507  	return m.MarshalToSizedBuffer(dAtA[:size])
   508  }
   509  
   510  func (m *AnyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   511  	i := len(dAtA)
   512  	_ = i
   513  	var l int
   514  	_ = l
   515  	if m.Value != nil {
   516  		{
   517  			size := m.Value.Size()
   518  			i -= size
   519  			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
   520  				return 0, err
   521  			}
   522  		}
   523  	}
   524  	return len(dAtA) - i, nil
   525  }
   526  
   527  func (m *AnyValue_StringValue) MarshalTo(dAtA []byte) (int, error) {
   528  	size := m.Size()
   529  	return m.MarshalToSizedBuffer(dAtA[:size])
   530  }
   531  
   532  func (m *AnyValue_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   533  	i := len(dAtA)
   534  	i -= len(m.StringValue)
   535  	copy(dAtA[i:], m.StringValue)
   536  	i = encodeVarintCommon(dAtA, i, uint64(len(m.StringValue)))
   537  	i--
   538  	dAtA[i] = 0xa
   539  	return len(dAtA) - i, nil
   540  }
   541  func (m *AnyValue_BoolValue) MarshalTo(dAtA []byte) (int, error) {
   542  	size := m.Size()
   543  	return m.MarshalToSizedBuffer(dAtA[:size])
   544  }
   545  
   546  func (m *AnyValue_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   547  	i := len(dAtA)
   548  	i--
   549  	if m.BoolValue {
   550  		dAtA[i] = 1
   551  	} else {
   552  		dAtA[i] = 0
   553  	}
   554  	i--
   555  	dAtA[i] = 0x10
   556  	return len(dAtA) - i, nil
   557  }
   558  func (m *AnyValue_IntValue) MarshalTo(dAtA []byte) (int, error) {
   559  	size := m.Size()
   560  	return m.MarshalToSizedBuffer(dAtA[:size])
   561  }
   562  
   563  func (m *AnyValue_IntValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   564  	i := len(dAtA)
   565  	i = encodeVarintCommon(dAtA, i, uint64(m.IntValue))
   566  	i--
   567  	dAtA[i] = 0x18
   568  	return len(dAtA) - i, nil
   569  }
   570  func (m *AnyValue_DoubleValue) MarshalTo(dAtA []byte) (int, error) {
   571  	size := m.Size()
   572  	return m.MarshalToSizedBuffer(dAtA[:size])
   573  }
   574  
   575  func (m *AnyValue_DoubleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   576  	i := len(dAtA)
   577  	i -= 8
   578  	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DoubleValue))))
   579  	i--
   580  	dAtA[i] = 0x21
   581  	return len(dAtA) - i, nil
   582  }
   583  func (m *AnyValue_ArrayValue) MarshalTo(dAtA []byte) (int, error) {
   584  	size := m.Size()
   585  	return m.MarshalToSizedBuffer(dAtA[:size])
   586  }
   587  
   588  func (m *AnyValue_ArrayValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   589  	i := len(dAtA)
   590  	if m.ArrayValue != nil {
   591  		{
   592  			size, err := m.ArrayValue.MarshalToSizedBuffer(dAtA[:i])
   593  			if err != nil {
   594  				return 0, err
   595  			}
   596  			i -= size
   597  			i = encodeVarintCommon(dAtA, i, uint64(size))
   598  		}
   599  		i--
   600  		dAtA[i] = 0x2a
   601  	}
   602  	return len(dAtA) - i, nil
   603  }
   604  func (m *AnyValue_KvlistValue) MarshalTo(dAtA []byte) (int, error) {
   605  	size := m.Size()
   606  	return m.MarshalToSizedBuffer(dAtA[:size])
   607  }
   608  
   609  func (m *AnyValue_KvlistValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   610  	i := len(dAtA)
   611  	if m.KvlistValue != nil {
   612  		{
   613  			size, err := m.KvlistValue.MarshalToSizedBuffer(dAtA[:i])
   614  			if err != nil {
   615  				return 0, err
   616  			}
   617  			i -= size
   618  			i = encodeVarintCommon(dAtA, i, uint64(size))
   619  		}
   620  		i--
   621  		dAtA[i] = 0x32
   622  	}
   623  	return len(dAtA) - i, nil
   624  }
   625  func (m *AnyValue_BytesValue) MarshalTo(dAtA []byte) (int, error) {
   626  	size := m.Size()
   627  	return m.MarshalToSizedBuffer(dAtA[:size])
   628  }
   629  
   630  func (m *AnyValue_BytesValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   631  	i := len(dAtA)
   632  	if m.BytesValue != nil {
   633  		i -= len(m.BytesValue)
   634  		copy(dAtA[i:], m.BytesValue)
   635  		i = encodeVarintCommon(dAtA, i, uint64(len(m.BytesValue)))
   636  		i--
   637  		dAtA[i] = 0x3a
   638  	}
   639  	return len(dAtA) - i, nil
   640  }
   641  func (m *ArrayValue) Marshal() (dAtA []byte, err error) {
   642  	size := m.Size()
   643  	dAtA = make([]byte, size)
   644  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   645  	if err != nil {
   646  		return nil, err
   647  	}
   648  	return dAtA[:n], nil
   649  }
   650  
   651  func (m *ArrayValue) MarshalTo(dAtA []byte) (int, error) {
   652  	size := m.Size()
   653  	return m.MarshalToSizedBuffer(dAtA[:size])
   654  }
   655  
   656  func (m *ArrayValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   657  	i := len(dAtA)
   658  	_ = i
   659  	var l int
   660  	_ = l
   661  	if len(m.Values) > 0 {
   662  		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
   663  			{
   664  				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   665  				if err != nil {
   666  					return 0, err
   667  				}
   668  				i -= size
   669  				i = encodeVarintCommon(dAtA, i, uint64(size))
   670  			}
   671  			i--
   672  			dAtA[i] = 0xa
   673  		}
   674  	}
   675  	return len(dAtA) - i, nil
   676  }
   677  
   678  func (m *KeyValueList) Marshal() (dAtA []byte, err error) {
   679  	size := m.Size()
   680  	dAtA = make([]byte, size)
   681  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   682  	if err != nil {
   683  		return nil, err
   684  	}
   685  	return dAtA[:n], nil
   686  }
   687  
   688  func (m *KeyValueList) MarshalTo(dAtA []byte) (int, error) {
   689  	size := m.Size()
   690  	return m.MarshalToSizedBuffer(dAtA[:size])
   691  }
   692  
   693  func (m *KeyValueList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   694  	i := len(dAtA)
   695  	_ = i
   696  	var l int
   697  	_ = l
   698  	if len(m.Values) > 0 {
   699  		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
   700  			{
   701  				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   702  				if err != nil {
   703  					return 0, err
   704  				}
   705  				i -= size
   706  				i = encodeVarintCommon(dAtA, i, uint64(size))
   707  			}
   708  			i--
   709  			dAtA[i] = 0xa
   710  		}
   711  	}
   712  	return len(dAtA) - i, nil
   713  }
   714  
   715  func (m *KeyValue) Marshal() (dAtA []byte, err error) {
   716  	size := m.Size()
   717  	dAtA = make([]byte, size)
   718  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   719  	if err != nil {
   720  		return nil, err
   721  	}
   722  	return dAtA[:n], nil
   723  }
   724  
   725  func (m *KeyValue) MarshalTo(dAtA []byte) (int, error) {
   726  	size := m.Size()
   727  	return m.MarshalToSizedBuffer(dAtA[:size])
   728  }
   729  
   730  func (m *KeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   731  	i := len(dAtA)
   732  	_ = i
   733  	var l int
   734  	_ = l
   735  	if m.Value != nil {
   736  		{
   737  			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
   738  			if err != nil {
   739  				return 0, err
   740  			}
   741  			i -= size
   742  			i = encodeVarintCommon(dAtA, i, uint64(size))
   743  		}
   744  		i--
   745  		dAtA[i] = 0x12
   746  	}
   747  	if len(m.Key) > 0 {
   748  		i -= len(m.Key)
   749  		copy(dAtA[i:], m.Key)
   750  		i = encodeVarintCommon(dAtA, i, uint64(len(m.Key)))
   751  		i--
   752  		dAtA[i] = 0xa
   753  	}
   754  	return len(dAtA) - i, nil
   755  }
   756  
   757  func (m *InstrumentationLibrary) Marshal() (dAtA []byte, err error) {
   758  	size := m.Size()
   759  	dAtA = make([]byte, size)
   760  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   761  	if err != nil {
   762  		return nil, err
   763  	}
   764  	return dAtA[:n], nil
   765  }
   766  
   767  func (m *InstrumentationLibrary) MarshalTo(dAtA []byte) (int, error) {
   768  	size := m.Size()
   769  	return m.MarshalToSizedBuffer(dAtA[:size])
   770  }
   771  
   772  func (m *InstrumentationLibrary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   773  	i := len(dAtA)
   774  	_ = i
   775  	var l int
   776  	_ = l
   777  	if len(m.Version) > 0 {
   778  		i -= len(m.Version)
   779  		copy(dAtA[i:], m.Version)
   780  		i = encodeVarintCommon(dAtA, i, uint64(len(m.Version)))
   781  		i--
   782  		dAtA[i] = 0x12
   783  	}
   784  	if len(m.Name) > 0 {
   785  		i -= len(m.Name)
   786  		copy(dAtA[i:], m.Name)
   787  		i = encodeVarintCommon(dAtA, i, uint64(len(m.Name)))
   788  		i--
   789  		dAtA[i] = 0xa
   790  	}
   791  	return len(dAtA) - i, nil
   792  }
   793  
   794  func (m *InstrumentationScope) Marshal() (dAtA []byte, err error) {
   795  	size := m.Size()
   796  	dAtA = make([]byte, size)
   797  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   798  	if err != nil {
   799  		return nil, err
   800  	}
   801  	return dAtA[:n], nil
   802  }
   803  
   804  func (m *InstrumentationScope) MarshalTo(dAtA []byte) (int, error) {
   805  	size := m.Size()
   806  	return m.MarshalToSizedBuffer(dAtA[:size])
   807  }
   808  
   809  func (m *InstrumentationScope) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   810  	i := len(dAtA)
   811  	_ = i
   812  	var l int
   813  	_ = l
   814  	if len(m.Version) > 0 {
   815  		i -= len(m.Version)
   816  		copy(dAtA[i:], m.Version)
   817  		i = encodeVarintCommon(dAtA, i, uint64(len(m.Version)))
   818  		i--
   819  		dAtA[i] = 0x12
   820  	}
   821  	if len(m.Name) > 0 {
   822  		i -= len(m.Name)
   823  		copy(dAtA[i:], m.Name)
   824  		i = encodeVarintCommon(dAtA, i, uint64(len(m.Name)))
   825  		i--
   826  		dAtA[i] = 0xa
   827  	}
   828  	return len(dAtA) - i, nil
   829  }
   830  
   831  func encodeVarintCommon(dAtA []byte, offset int, v uint64) int {
   832  	offset -= sovCommon(v)
   833  	base := offset
   834  	for v >= 1<<7 {
   835  		dAtA[offset] = uint8(v&0x7f | 0x80)
   836  		v >>= 7
   837  		offset++
   838  	}
   839  	dAtA[offset] = uint8(v)
   840  	return base
   841  }
   842  func (m *AnyValue) Size() (n int) {
   843  	if m == nil {
   844  		return 0
   845  	}
   846  	var l int
   847  	_ = l
   848  	if m.Value != nil {
   849  		n += m.Value.Size()
   850  	}
   851  	return n
   852  }
   853  
   854  func (m *AnyValue_StringValue) Size() (n int) {
   855  	if m == nil {
   856  		return 0
   857  	}
   858  	var l int
   859  	_ = l
   860  	l = len(m.StringValue)
   861  	n += 1 + l + sovCommon(uint64(l))
   862  	return n
   863  }
   864  func (m *AnyValue_BoolValue) Size() (n int) {
   865  	if m == nil {
   866  		return 0
   867  	}
   868  	var l int
   869  	_ = l
   870  	n += 2
   871  	return n
   872  }
   873  func (m *AnyValue_IntValue) Size() (n int) {
   874  	if m == nil {
   875  		return 0
   876  	}
   877  	var l int
   878  	_ = l
   879  	n += 1 + sovCommon(uint64(m.IntValue))
   880  	return n
   881  }
   882  func (m *AnyValue_DoubleValue) Size() (n int) {
   883  	if m == nil {
   884  		return 0
   885  	}
   886  	var l int
   887  	_ = l
   888  	n += 9
   889  	return n
   890  }
   891  func (m *AnyValue_ArrayValue) Size() (n int) {
   892  	if m == nil {
   893  		return 0
   894  	}
   895  	var l int
   896  	_ = l
   897  	if m.ArrayValue != nil {
   898  		l = m.ArrayValue.Size()
   899  		n += 1 + l + sovCommon(uint64(l))
   900  	}
   901  	return n
   902  }
   903  func (m *AnyValue_KvlistValue) Size() (n int) {
   904  	if m == nil {
   905  		return 0
   906  	}
   907  	var l int
   908  	_ = l
   909  	if m.KvlistValue != nil {
   910  		l = m.KvlistValue.Size()
   911  		n += 1 + l + sovCommon(uint64(l))
   912  	}
   913  	return n
   914  }
   915  func (m *AnyValue_BytesValue) Size() (n int) {
   916  	if m == nil {
   917  		return 0
   918  	}
   919  	var l int
   920  	_ = l
   921  	if m.BytesValue != nil {
   922  		l = len(m.BytesValue)
   923  		n += 1 + l + sovCommon(uint64(l))
   924  	}
   925  	return n
   926  }
   927  func (m *ArrayValue) Size() (n int) {
   928  	if m == nil {
   929  		return 0
   930  	}
   931  	var l int
   932  	_ = l
   933  	if len(m.Values) > 0 {
   934  		for _, e := range m.Values {
   935  			l = e.Size()
   936  			n += 1 + l + sovCommon(uint64(l))
   937  		}
   938  	}
   939  	return n
   940  }
   941  
   942  func (m *KeyValueList) Size() (n int) {
   943  	if m == nil {
   944  		return 0
   945  	}
   946  	var l int
   947  	_ = l
   948  	if len(m.Values) > 0 {
   949  		for _, e := range m.Values {
   950  			l = e.Size()
   951  			n += 1 + l + sovCommon(uint64(l))
   952  		}
   953  	}
   954  	return n
   955  }
   956  
   957  func (m *KeyValue) Size() (n int) {
   958  	if m == nil {
   959  		return 0
   960  	}
   961  	var l int
   962  	_ = l
   963  	l = len(m.Key)
   964  	if l > 0 {
   965  		n += 1 + l + sovCommon(uint64(l))
   966  	}
   967  	if m.Value != nil {
   968  		l = m.Value.Size()
   969  		n += 1 + l + sovCommon(uint64(l))
   970  	}
   971  	return n
   972  }
   973  
   974  func (m *InstrumentationLibrary) Size() (n int) {
   975  	if m == nil {
   976  		return 0
   977  	}
   978  	var l int
   979  	_ = l
   980  	l = len(m.Name)
   981  	if l > 0 {
   982  		n += 1 + l + sovCommon(uint64(l))
   983  	}
   984  	l = len(m.Version)
   985  	if l > 0 {
   986  		n += 1 + l + sovCommon(uint64(l))
   987  	}
   988  	return n
   989  }
   990  
   991  func (m *InstrumentationScope) Size() (n int) {
   992  	if m == nil {
   993  		return 0
   994  	}
   995  	var l int
   996  	_ = l
   997  	l = len(m.Name)
   998  	if l > 0 {
   999  		n += 1 + l + sovCommon(uint64(l))
  1000  	}
  1001  	l = len(m.Version)
  1002  	if l > 0 {
  1003  		n += 1 + l + sovCommon(uint64(l))
  1004  	}
  1005  	return n
  1006  }
  1007  
  1008  func sovCommon(x uint64) (n int) {
  1009  	return (math_bits.Len64(x|1) + 6) / 7
  1010  }
  1011  func sozCommon(x uint64) (n int) {
  1012  	return sovCommon(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1013  }
  1014  func (m *AnyValue) Unmarshal(dAtA []byte) error {
  1015  	l := len(dAtA)
  1016  	iNdEx := 0
  1017  	for iNdEx < l {
  1018  		preIndex := iNdEx
  1019  		var wire uint64
  1020  		for shift := uint(0); ; shift += 7 {
  1021  			if shift >= 64 {
  1022  				return ErrIntOverflowCommon
  1023  			}
  1024  			if iNdEx >= l {
  1025  				return io.ErrUnexpectedEOF
  1026  			}
  1027  			b := dAtA[iNdEx]
  1028  			iNdEx++
  1029  			wire |= uint64(b&0x7F) << shift
  1030  			if b < 0x80 {
  1031  				break
  1032  			}
  1033  		}
  1034  		fieldNum := int32(wire >> 3)
  1035  		wireType := int(wire & 0x7)
  1036  		if wireType == 4 {
  1037  			return fmt.Errorf("proto: AnyValue: wiretype end group for non-group")
  1038  		}
  1039  		if fieldNum <= 0 {
  1040  			return fmt.Errorf("proto: AnyValue: illegal tag %d (wire type %d)", fieldNum, wire)
  1041  		}
  1042  		switch fieldNum {
  1043  		case 1:
  1044  			if wireType != 2 {
  1045  				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
  1046  			}
  1047  			var stringLen uint64
  1048  			for shift := uint(0); ; shift += 7 {
  1049  				if shift >= 64 {
  1050  					return ErrIntOverflowCommon
  1051  				}
  1052  				if iNdEx >= l {
  1053  					return io.ErrUnexpectedEOF
  1054  				}
  1055  				b := dAtA[iNdEx]
  1056  				iNdEx++
  1057  				stringLen |= uint64(b&0x7F) << shift
  1058  				if b < 0x80 {
  1059  					break
  1060  				}
  1061  			}
  1062  			intStringLen := int(stringLen)
  1063  			if intStringLen < 0 {
  1064  				return ErrInvalidLengthCommon
  1065  			}
  1066  			postIndex := iNdEx + intStringLen
  1067  			if postIndex < 0 {
  1068  				return ErrInvalidLengthCommon
  1069  			}
  1070  			if postIndex > l {
  1071  				return io.ErrUnexpectedEOF
  1072  			}
  1073  			m.Value = &AnyValue_StringValue{string(dAtA[iNdEx:postIndex])}
  1074  			iNdEx = postIndex
  1075  		case 2:
  1076  			if wireType != 0 {
  1077  				return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
  1078  			}
  1079  			var v int
  1080  			for shift := uint(0); ; shift += 7 {
  1081  				if shift >= 64 {
  1082  					return ErrIntOverflowCommon
  1083  				}
  1084  				if iNdEx >= l {
  1085  					return io.ErrUnexpectedEOF
  1086  				}
  1087  				b := dAtA[iNdEx]
  1088  				iNdEx++
  1089  				v |= int(b&0x7F) << shift
  1090  				if b < 0x80 {
  1091  					break
  1092  				}
  1093  			}
  1094  			b := bool(v != 0)
  1095  			m.Value = &AnyValue_BoolValue{b}
  1096  		case 3:
  1097  			if wireType != 0 {
  1098  				return fmt.Errorf("proto: wrong wireType = %d for field IntValue", wireType)
  1099  			}
  1100  			var v int64
  1101  			for shift := uint(0); ; shift += 7 {
  1102  				if shift >= 64 {
  1103  					return ErrIntOverflowCommon
  1104  				}
  1105  				if iNdEx >= l {
  1106  					return io.ErrUnexpectedEOF
  1107  				}
  1108  				b := dAtA[iNdEx]
  1109  				iNdEx++
  1110  				v |= int64(b&0x7F) << shift
  1111  				if b < 0x80 {
  1112  					break
  1113  				}
  1114  			}
  1115  			m.Value = &AnyValue_IntValue{v}
  1116  		case 4:
  1117  			if wireType != 1 {
  1118  				return fmt.Errorf("proto: wrong wireType = %d for field DoubleValue", wireType)
  1119  			}
  1120  			var v uint64
  1121  			if (iNdEx + 8) > l {
  1122  				return io.ErrUnexpectedEOF
  1123  			}
  1124  			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
  1125  			iNdEx += 8
  1126  			m.Value = &AnyValue_DoubleValue{float64(math.Float64frombits(v))}
  1127  		case 5:
  1128  			if wireType != 2 {
  1129  				return fmt.Errorf("proto: wrong wireType = %d for field ArrayValue", wireType)
  1130  			}
  1131  			var msglen int
  1132  			for shift := uint(0); ; shift += 7 {
  1133  				if shift >= 64 {
  1134  					return ErrIntOverflowCommon
  1135  				}
  1136  				if iNdEx >= l {
  1137  					return io.ErrUnexpectedEOF
  1138  				}
  1139  				b := dAtA[iNdEx]
  1140  				iNdEx++
  1141  				msglen |= int(b&0x7F) << shift
  1142  				if b < 0x80 {
  1143  					break
  1144  				}
  1145  			}
  1146  			if msglen < 0 {
  1147  				return ErrInvalidLengthCommon
  1148  			}
  1149  			postIndex := iNdEx + msglen
  1150  			if postIndex < 0 {
  1151  				return ErrInvalidLengthCommon
  1152  			}
  1153  			if postIndex > l {
  1154  				return io.ErrUnexpectedEOF
  1155  			}
  1156  			v := &ArrayValue{}
  1157  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1158  				return err
  1159  			}
  1160  			m.Value = &AnyValue_ArrayValue{v}
  1161  			iNdEx = postIndex
  1162  		case 6:
  1163  			if wireType != 2 {
  1164  				return fmt.Errorf("proto: wrong wireType = %d for field KvlistValue", wireType)
  1165  			}
  1166  			var msglen int
  1167  			for shift := uint(0); ; shift += 7 {
  1168  				if shift >= 64 {
  1169  					return ErrIntOverflowCommon
  1170  				}
  1171  				if iNdEx >= l {
  1172  					return io.ErrUnexpectedEOF
  1173  				}
  1174  				b := dAtA[iNdEx]
  1175  				iNdEx++
  1176  				msglen |= int(b&0x7F) << shift
  1177  				if b < 0x80 {
  1178  					break
  1179  				}
  1180  			}
  1181  			if msglen < 0 {
  1182  				return ErrInvalidLengthCommon
  1183  			}
  1184  			postIndex := iNdEx + msglen
  1185  			if postIndex < 0 {
  1186  				return ErrInvalidLengthCommon
  1187  			}
  1188  			if postIndex > l {
  1189  				return io.ErrUnexpectedEOF
  1190  			}
  1191  			v := &KeyValueList{}
  1192  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1193  				return err
  1194  			}
  1195  			m.Value = &AnyValue_KvlistValue{v}
  1196  			iNdEx = postIndex
  1197  		case 7:
  1198  			if wireType != 2 {
  1199  				return fmt.Errorf("proto: wrong wireType = %d for field BytesValue", wireType)
  1200  			}
  1201  			var byteLen int
  1202  			for shift := uint(0); ; shift += 7 {
  1203  				if shift >= 64 {
  1204  					return ErrIntOverflowCommon
  1205  				}
  1206  				if iNdEx >= l {
  1207  					return io.ErrUnexpectedEOF
  1208  				}
  1209  				b := dAtA[iNdEx]
  1210  				iNdEx++
  1211  				byteLen |= int(b&0x7F) << shift
  1212  				if b < 0x80 {
  1213  					break
  1214  				}
  1215  			}
  1216  			if byteLen < 0 {
  1217  				return ErrInvalidLengthCommon
  1218  			}
  1219  			postIndex := iNdEx + byteLen
  1220  			if postIndex < 0 {
  1221  				return ErrInvalidLengthCommon
  1222  			}
  1223  			if postIndex > l {
  1224  				return io.ErrUnexpectedEOF
  1225  			}
  1226  			v := make([]byte, postIndex-iNdEx)
  1227  			copy(v, dAtA[iNdEx:postIndex])
  1228  			m.Value = &AnyValue_BytesValue{v}
  1229  			iNdEx = postIndex
  1230  		default:
  1231  			iNdEx = preIndex
  1232  			skippy, err := skipCommon(dAtA[iNdEx:])
  1233  			if err != nil {
  1234  				return err
  1235  			}
  1236  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1237  				return ErrInvalidLengthCommon
  1238  			}
  1239  			if (iNdEx + skippy) > l {
  1240  				return io.ErrUnexpectedEOF
  1241  			}
  1242  			iNdEx += skippy
  1243  		}
  1244  	}
  1245  
  1246  	if iNdEx > l {
  1247  		return io.ErrUnexpectedEOF
  1248  	}
  1249  	return nil
  1250  }
  1251  func (m *ArrayValue) Unmarshal(dAtA []byte) error {
  1252  	l := len(dAtA)
  1253  	iNdEx := 0
  1254  	for iNdEx < l {
  1255  		preIndex := iNdEx
  1256  		var wire uint64
  1257  		for shift := uint(0); ; shift += 7 {
  1258  			if shift >= 64 {
  1259  				return ErrIntOverflowCommon
  1260  			}
  1261  			if iNdEx >= l {
  1262  				return io.ErrUnexpectedEOF
  1263  			}
  1264  			b := dAtA[iNdEx]
  1265  			iNdEx++
  1266  			wire |= uint64(b&0x7F) << shift
  1267  			if b < 0x80 {
  1268  				break
  1269  			}
  1270  		}
  1271  		fieldNum := int32(wire >> 3)
  1272  		wireType := int(wire & 0x7)
  1273  		if wireType == 4 {
  1274  			return fmt.Errorf("proto: ArrayValue: wiretype end group for non-group")
  1275  		}
  1276  		if fieldNum <= 0 {
  1277  			return fmt.Errorf("proto: ArrayValue: illegal tag %d (wire type %d)", fieldNum, wire)
  1278  		}
  1279  		switch fieldNum {
  1280  		case 1:
  1281  			if wireType != 2 {
  1282  				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
  1283  			}
  1284  			var msglen int
  1285  			for shift := uint(0); ; shift += 7 {
  1286  				if shift >= 64 {
  1287  					return ErrIntOverflowCommon
  1288  				}
  1289  				if iNdEx >= l {
  1290  					return io.ErrUnexpectedEOF
  1291  				}
  1292  				b := dAtA[iNdEx]
  1293  				iNdEx++
  1294  				msglen |= int(b&0x7F) << shift
  1295  				if b < 0x80 {
  1296  					break
  1297  				}
  1298  			}
  1299  			if msglen < 0 {
  1300  				return ErrInvalidLengthCommon
  1301  			}
  1302  			postIndex := iNdEx + msglen
  1303  			if postIndex < 0 {
  1304  				return ErrInvalidLengthCommon
  1305  			}
  1306  			if postIndex > l {
  1307  				return io.ErrUnexpectedEOF
  1308  			}
  1309  			m.Values = append(m.Values, &AnyValue{})
  1310  			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1311  				return err
  1312  			}
  1313  			iNdEx = postIndex
  1314  		default:
  1315  			iNdEx = preIndex
  1316  			skippy, err := skipCommon(dAtA[iNdEx:])
  1317  			if err != nil {
  1318  				return err
  1319  			}
  1320  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1321  				return ErrInvalidLengthCommon
  1322  			}
  1323  			if (iNdEx + skippy) > l {
  1324  				return io.ErrUnexpectedEOF
  1325  			}
  1326  			iNdEx += skippy
  1327  		}
  1328  	}
  1329  
  1330  	if iNdEx > l {
  1331  		return io.ErrUnexpectedEOF
  1332  	}
  1333  	return nil
  1334  }
  1335  func (m *KeyValueList) Unmarshal(dAtA []byte) error {
  1336  	l := len(dAtA)
  1337  	iNdEx := 0
  1338  	for iNdEx < l {
  1339  		preIndex := iNdEx
  1340  		var wire uint64
  1341  		for shift := uint(0); ; shift += 7 {
  1342  			if shift >= 64 {
  1343  				return ErrIntOverflowCommon
  1344  			}
  1345  			if iNdEx >= l {
  1346  				return io.ErrUnexpectedEOF
  1347  			}
  1348  			b := dAtA[iNdEx]
  1349  			iNdEx++
  1350  			wire |= uint64(b&0x7F) << shift
  1351  			if b < 0x80 {
  1352  				break
  1353  			}
  1354  		}
  1355  		fieldNum := int32(wire >> 3)
  1356  		wireType := int(wire & 0x7)
  1357  		if wireType == 4 {
  1358  			return fmt.Errorf("proto: KeyValueList: wiretype end group for non-group")
  1359  		}
  1360  		if fieldNum <= 0 {
  1361  			return fmt.Errorf("proto: KeyValueList: illegal tag %d (wire type %d)", fieldNum, wire)
  1362  		}
  1363  		switch fieldNum {
  1364  		case 1:
  1365  			if wireType != 2 {
  1366  				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
  1367  			}
  1368  			var msglen int
  1369  			for shift := uint(0); ; shift += 7 {
  1370  				if shift >= 64 {
  1371  					return ErrIntOverflowCommon
  1372  				}
  1373  				if iNdEx >= l {
  1374  					return io.ErrUnexpectedEOF
  1375  				}
  1376  				b := dAtA[iNdEx]
  1377  				iNdEx++
  1378  				msglen |= int(b&0x7F) << shift
  1379  				if b < 0x80 {
  1380  					break
  1381  				}
  1382  			}
  1383  			if msglen < 0 {
  1384  				return ErrInvalidLengthCommon
  1385  			}
  1386  			postIndex := iNdEx + msglen
  1387  			if postIndex < 0 {
  1388  				return ErrInvalidLengthCommon
  1389  			}
  1390  			if postIndex > l {
  1391  				return io.ErrUnexpectedEOF
  1392  			}
  1393  			m.Values = append(m.Values, &KeyValue{})
  1394  			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1395  				return err
  1396  			}
  1397  			iNdEx = postIndex
  1398  		default:
  1399  			iNdEx = preIndex
  1400  			skippy, err := skipCommon(dAtA[iNdEx:])
  1401  			if err != nil {
  1402  				return err
  1403  			}
  1404  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1405  				return ErrInvalidLengthCommon
  1406  			}
  1407  			if (iNdEx + skippy) > l {
  1408  				return io.ErrUnexpectedEOF
  1409  			}
  1410  			iNdEx += skippy
  1411  		}
  1412  	}
  1413  
  1414  	if iNdEx > l {
  1415  		return io.ErrUnexpectedEOF
  1416  	}
  1417  	return nil
  1418  }
  1419  func (m *KeyValue) Unmarshal(dAtA []byte) error {
  1420  	l := len(dAtA)
  1421  	iNdEx := 0
  1422  	for iNdEx < l {
  1423  		preIndex := iNdEx
  1424  		var wire uint64
  1425  		for shift := uint(0); ; shift += 7 {
  1426  			if shift >= 64 {
  1427  				return ErrIntOverflowCommon
  1428  			}
  1429  			if iNdEx >= l {
  1430  				return io.ErrUnexpectedEOF
  1431  			}
  1432  			b := dAtA[iNdEx]
  1433  			iNdEx++
  1434  			wire |= uint64(b&0x7F) << shift
  1435  			if b < 0x80 {
  1436  				break
  1437  			}
  1438  		}
  1439  		fieldNum := int32(wire >> 3)
  1440  		wireType := int(wire & 0x7)
  1441  		if wireType == 4 {
  1442  			return fmt.Errorf("proto: KeyValue: wiretype end group for non-group")
  1443  		}
  1444  		if fieldNum <= 0 {
  1445  			return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire)
  1446  		}
  1447  		switch fieldNum {
  1448  		case 1:
  1449  			if wireType != 2 {
  1450  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  1451  			}
  1452  			var stringLen uint64
  1453  			for shift := uint(0); ; shift += 7 {
  1454  				if shift >= 64 {
  1455  					return ErrIntOverflowCommon
  1456  				}
  1457  				if iNdEx >= l {
  1458  					return io.ErrUnexpectedEOF
  1459  				}
  1460  				b := dAtA[iNdEx]
  1461  				iNdEx++
  1462  				stringLen |= uint64(b&0x7F) << shift
  1463  				if b < 0x80 {
  1464  					break
  1465  				}
  1466  			}
  1467  			intStringLen := int(stringLen)
  1468  			if intStringLen < 0 {
  1469  				return ErrInvalidLengthCommon
  1470  			}
  1471  			postIndex := iNdEx + intStringLen
  1472  			if postIndex < 0 {
  1473  				return ErrInvalidLengthCommon
  1474  			}
  1475  			if postIndex > l {
  1476  				return io.ErrUnexpectedEOF
  1477  			}
  1478  			m.Key = string(dAtA[iNdEx:postIndex])
  1479  			iNdEx = postIndex
  1480  		case 2:
  1481  			if wireType != 2 {
  1482  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  1483  			}
  1484  			var msglen int
  1485  			for shift := uint(0); ; shift += 7 {
  1486  				if shift >= 64 {
  1487  					return ErrIntOverflowCommon
  1488  				}
  1489  				if iNdEx >= l {
  1490  					return io.ErrUnexpectedEOF
  1491  				}
  1492  				b := dAtA[iNdEx]
  1493  				iNdEx++
  1494  				msglen |= int(b&0x7F) << shift
  1495  				if b < 0x80 {
  1496  					break
  1497  				}
  1498  			}
  1499  			if msglen < 0 {
  1500  				return ErrInvalidLengthCommon
  1501  			}
  1502  			postIndex := iNdEx + msglen
  1503  			if postIndex < 0 {
  1504  				return ErrInvalidLengthCommon
  1505  			}
  1506  			if postIndex > l {
  1507  				return io.ErrUnexpectedEOF
  1508  			}
  1509  			if m.Value == nil {
  1510  				m.Value = &AnyValue{}
  1511  			}
  1512  			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1513  				return err
  1514  			}
  1515  			iNdEx = postIndex
  1516  		default:
  1517  			iNdEx = preIndex
  1518  			skippy, err := skipCommon(dAtA[iNdEx:])
  1519  			if err != nil {
  1520  				return err
  1521  			}
  1522  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1523  				return ErrInvalidLengthCommon
  1524  			}
  1525  			if (iNdEx + skippy) > l {
  1526  				return io.ErrUnexpectedEOF
  1527  			}
  1528  			iNdEx += skippy
  1529  		}
  1530  	}
  1531  
  1532  	if iNdEx > l {
  1533  		return io.ErrUnexpectedEOF
  1534  	}
  1535  	return nil
  1536  }
  1537  func (m *InstrumentationLibrary) Unmarshal(dAtA []byte) error {
  1538  	l := len(dAtA)
  1539  	iNdEx := 0
  1540  	for iNdEx < l {
  1541  		preIndex := iNdEx
  1542  		var wire uint64
  1543  		for shift := uint(0); ; shift += 7 {
  1544  			if shift >= 64 {
  1545  				return ErrIntOverflowCommon
  1546  			}
  1547  			if iNdEx >= l {
  1548  				return io.ErrUnexpectedEOF
  1549  			}
  1550  			b := dAtA[iNdEx]
  1551  			iNdEx++
  1552  			wire |= uint64(b&0x7F) << shift
  1553  			if b < 0x80 {
  1554  				break
  1555  			}
  1556  		}
  1557  		fieldNum := int32(wire >> 3)
  1558  		wireType := int(wire & 0x7)
  1559  		if wireType == 4 {
  1560  			return fmt.Errorf("proto: InstrumentationLibrary: wiretype end group for non-group")
  1561  		}
  1562  		if fieldNum <= 0 {
  1563  			return fmt.Errorf("proto: InstrumentationLibrary: illegal tag %d (wire type %d)", fieldNum, wire)
  1564  		}
  1565  		switch fieldNum {
  1566  		case 1:
  1567  			if wireType != 2 {
  1568  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  1569  			}
  1570  			var stringLen uint64
  1571  			for shift := uint(0); ; shift += 7 {
  1572  				if shift >= 64 {
  1573  					return ErrIntOverflowCommon
  1574  				}
  1575  				if iNdEx >= l {
  1576  					return io.ErrUnexpectedEOF
  1577  				}
  1578  				b := dAtA[iNdEx]
  1579  				iNdEx++
  1580  				stringLen |= uint64(b&0x7F) << shift
  1581  				if b < 0x80 {
  1582  					break
  1583  				}
  1584  			}
  1585  			intStringLen := int(stringLen)
  1586  			if intStringLen < 0 {
  1587  				return ErrInvalidLengthCommon
  1588  			}
  1589  			postIndex := iNdEx + intStringLen
  1590  			if postIndex < 0 {
  1591  				return ErrInvalidLengthCommon
  1592  			}
  1593  			if postIndex > l {
  1594  				return io.ErrUnexpectedEOF
  1595  			}
  1596  			m.Name = string(dAtA[iNdEx:postIndex])
  1597  			iNdEx = postIndex
  1598  		case 2:
  1599  			if wireType != 2 {
  1600  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  1601  			}
  1602  			var stringLen uint64
  1603  			for shift := uint(0); ; shift += 7 {
  1604  				if shift >= 64 {
  1605  					return ErrIntOverflowCommon
  1606  				}
  1607  				if iNdEx >= l {
  1608  					return io.ErrUnexpectedEOF
  1609  				}
  1610  				b := dAtA[iNdEx]
  1611  				iNdEx++
  1612  				stringLen |= uint64(b&0x7F) << shift
  1613  				if b < 0x80 {
  1614  					break
  1615  				}
  1616  			}
  1617  			intStringLen := int(stringLen)
  1618  			if intStringLen < 0 {
  1619  				return ErrInvalidLengthCommon
  1620  			}
  1621  			postIndex := iNdEx + intStringLen
  1622  			if postIndex < 0 {
  1623  				return ErrInvalidLengthCommon
  1624  			}
  1625  			if postIndex > l {
  1626  				return io.ErrUnexpectedEOF
  1627  			}
  1628  			m.Version = string(dAtA[iNdEx:postIndex])
  1629  			iNdEx = postIndex
  1630  		default:
  1631  			iNdEx = preIndex
  1632  			skippy, err := skipCommon(dAtA[iNdEx:])
  1633  			if err != nil {
  1634  				return err
  1635  			}
  1636  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1637  				return ErrInvalidLengthCommon
  1638  			}
  1639  			if (iNdEx + skippy) > l {
  1640  				return io.ErrUnexpectedEOF
  1641  			}
  1642  			iNdEx += skippy
  1643  		}
  1644  	}
  1645  
  1646  	if iNdEx > l {
  1647  		return io.ErrUnexpectedEOF
  1648  	}
  1649  	return nil
  1650  }
  1651  func (m *InstrumentationScope) Unmarshal(dAtA []byte) error {
  1652  	l := len(dAtA)
  1653  	iNdEx := 0
  1654  	for iNdEx < l {
  1655  		preIndex := iNdEx
  1656  		var wire uint64
  1657  		for shift := uint(0); ; shift += 7 {
  1658  			if shift >= 64 {
  1659  				return ErrIntOverflowCommon
  1660  			}
  1661  			if iNdEx >= l {
  1662  				return io.ErrUnexpectedEOF
  1663  			}
  1664  			b := dAtA[iNdEx]
  1665  			iNdEx++
  1666  			wire |= uint64(b&0x7F) << shift
  1667  			if b < 0x80 {
  1668  				break
  1669  			}
  1670  		}
  1671  		fieldNum := int32(wire >> 3)
  1672  		wireType := int(wire & 0x7)
  1673  		if wireType == 4 {
  1674  			return fmt.Errorf("proto: InstrumentationScope: wiretype end group for non-group")
  1675  		}
  1676  		if fieldNum <= 0 {
  1677  			return fmt.Errorf("proto: InstrumentationScope: illegal tag %d (wire type %d)", fieldNum, wire)
  1678  		}
  1679  		switch fieldNum {
  1680  		case 1:
  1681  			if wireType != 2 {
  1682  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  1683  			}
  1684  			var stringLen uint64
  1685  			for shift := uint(0); ; shift += 7 {
  1686  				if shift >= 64 {
  1687  					return ErrIntOverflowCommon
  1688  				}
  1689  				if iNdEx >= l {
  1690  					return io.ErrUnexpectedEOF
  1691  				}
  1692  				b := dAtA[iNdEx]
  1693  				iNdEx++
  1694  				stringLen |= uint64(b&0x7F) << shift
  1695  				if b < 0x80 {
  1696  					break
  1697  				}
  1698  			}
  1699  			intStringLen := int(stringLen)
  1700  			if intStringLen < 0 {
  1701  				return ErrInvalidLengthCommon
  1702  			}
  1703  			postIndex := iNdEx + intStringLen
  1704  			if postIndex < 0 {
  1705  				return ErrInvalidLengthCommon
  1706  			}
  1707  			if postIndex > l {
  1708  				return io.ErrUnexpectedEOF
  1709  			}
  1710  			m.Name = string(dAtA[iNdEx:postIndex])
  1711  			iNdEx = postIndex
  1712  		case 2:
  1713  			if wireType != 2 {
  1714  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  1715  			}
  1716  			var stringLen uint64
  1717  			for shift := uint(0); ; shift += 7 {
  1718  				if shift >= 64 {
  1719  					return ErrIntOverflowCommon
  1720  				}
  1721  				if iNdEx >= l {
  1722  					return io.ErrUnexpectedEOF
  1723  				}
  1724  				b := dAtA[iNdEx]
  1725  				iNdEx++
  1726  				stringLen |= uint64(b&0x7F) << shift
  1727  				if b < 0x80 {
  1728  					break
  1729  				}
  1730  			}
  1731  			intStringLen := int(stringLen)
  1732  			if intStringLen < 0 {
  1733  				return ErrInvalidLengthCommon
  1734  			}
  1735  			postIndex := iNdEx + intStringLen
  1736  			if postIndex < 0 {
  1737  				return ErrInvalidLengthCommon
  1738  			}
  1739  			if postIndex > l {
  1740  				return io.ErrUnexpectedEOF
  1741  			}
  1742  			m.Version = string(dAtA[iNdEx:postIndex])
  1743  			iNdEx = postIndex
  1744  		default:
  1745  			iNdEx = preIndex
  1746  			skippy, err := skipCommon(dAtA[iNdEx:])
  1747  			if err != nil {
  1748  				return err
  1749  			}
  1750  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1751  				return ErrInvalidLengthCommon
  1752  			}
  1753  			if (iNdEx + skippy) > l {
  1754  				return io.ErrUnexpectedEOF
  1755  			}
  1756  			iNdEx += skippy
  1757  		}
  1758  	}
  1759  
  1760  	if iNdEx > l {
  1761  		return io.ErrUnexpectedEOF
  1762  	}
  1763  	return nil
  1764  }
  1765  func skipCommon(dAtA []byte) (n int, err error) {
  1766  	l := len(dAtA)
  1767  	iNdEx := 0
  1768  	depth := 0
  1769  	for iNdEx < l {
  1770  		var wire uint64
  1771  		for shift := uint(0); ; shift += 7 {
  1772  			if shift >= 64 {
  1773  				return 0, ErrIntOverflowCommon
  1774  			}
  1775  			if iNdEx >= l {
  1776  				return 0, io.ErrUnexpectedEOF
  1777  			}
  1778  			b := dAtA[iNdEx]
  1779  			iNdEx++
  1780  			wire |= (uint64(b) & 0x7F) << shift
  1781  			if b < 0x80 {
  1782  				break
  1783  			}
  1784  		}
  1785  		wireType := int(wire & 0x7)
  1786  		switch wireType {
  1787  		case 0:
  1788  			for shift := uint(0); ; shift += 7 {
  1789  				if shift >= 64 {
  1790  					return 0, ErrIntOverflowCommon
  1791  				}
  1792  				if iNdEx >= l {
  1793  					return 0, io.ErrUnexpectedEOF
  1794  				}
  1795  				iNdEx++
  1796  				if dAtA[iNdEx-1] < 0x80 {
  1797  					break
  1798  				}
  1799  			}
  1800  		case 1:
  1801  			iNdEx += 8
  1802  		case 2:
  1803  			var length int
  1804  			for shift := uint(0); ; shift += 7 {
  1805  				if shift >= 64 {
  1806  					return 0, ErrIntOverflowCommon
  1807  				}
  1808  				if iNdEx >= l {
  1809  					return 0, io.ErrUnexpectedEOF
  1810  				}
  1811  				b := dAtA[iNdEx]
  1812  				iNdEx++
  1813  				length |= (int(b) & 0x7F) << shift
  1814  				if b < 0x80 {
  1815  					break
  1816  				}
  1817  			}
  1818  			if length < 0 {
  1819  				return 0, ErrInvalidLengthCommon
  1820  			}
  1821  			iNdEx += length
  1822  		case 3:
  1823  			depth++
  1824  		case 4:
  1825  			if depth == 0 {
  1826  				return 0, ErrUnexpectedEndOfGroupCommon
  1827  			}
  1828  			depth--
  1829  		case 5:
  1830  			iNdEx += 4
  1831  		default:
  1832  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1833  		}
  1834  		if iNdEx < 0 {
  1835  			return 0, ErrInvalidLengthCommon
  1836  		}
  1837  		if depth == 0 {
  1838  			return iNdEx, nil
  1839  		}
  1840  	}
  1841  	return 0, io.ErrUnexpectedEOF
  1842  }
  1843  
  1844  var (
  1845  	ErrInvalidLengthCommon        = fmt.Errorf("proto: negative length found during unmarshaling")
  1846  	ErrIntOverflowCommon          = fmt.Errorf("proto: integer overflow")
  1847  	ErrUnexpectedEndOfGroupCommon = fmt.Errorf("proto: unexpected end of group")
  1848  )