github.com/team-ide/go-dialect@v1.9.20/vitess/query/query_vtproto.pb.go (about)

     1  // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
     2  // protoc-gen-go-vtproto version: v0.2.0
     3  // source: query.proto
     4  
     5  package query
     6  
     7  import (
     8  	binary "encoding/binary"
     9  	fmt "fmt"
    10  	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
    11  	io "io"
    12  	math "math"
    13  	bits "math/bits"
    14  	sync "sync"
    15  	topodata "github.com/team-ide/go-dialect/vitess/topodata"
    16  	vtrpc "github.com/team-ide/go-dialect/vitess/vtrpc"
    17  )
    18  
    19  const (
    20  	// Verify that this generated code is sufficiently up-to-date.
    21  	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
    22  	// Verify that runtime/protoimpl is sufficiently up-to-date.
    23  	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
    24  )
    25  
    26  func (m *Target) MarshalVT() (dAtA []byte, err error) {
    27  	if m == nil {
    28  		return nil, nil
    29  	}
    30  	size := m.SizeVT()
    31  	dAtA = make([]byte, size)
    32  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
    33  	if err != nil {
    34  		return nil, err
    35  	}
    36  	return dAtA[:n], nil
    37  }
    38  
    39  func (m *Target) MarshalToVT(dAtA []byte) (int, error) {
    40  	size := m.SizeVT()
    41  	return m.MarshalToSizedBufferVT(dAtA[:size])
    42  }
    43  
    44  func (m *Target) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
    45  	if m == nil {
    46  		return 0, nil
    47  	}
    48  	i := len(dAtA)
    49  	_ = i
    50  	var l int
    51  	_ = l
    52  	if m.unknownFields != nil {
    53  		i -= len(m.unknownFields)
    54  		copy(dAtA[i:], m.unknownFields)
    55  	}
    56  	if len(m.Cell) > 0 {
    57  		i -= len(m.Cell)
    58  		copy(dAtA[i:], m.Cell)
    59  		i = encodeVarint(dAtA, i, uint64(len(m.Cell)))
    60  		i--
    61  		dAtA[i] = 0x22
    62  	}
    63  	if m.TabletType != 0 {
    64  		i = encodeVarint(dAtA, i, uint64(m.TabletType))
    65  		i--
    66  		dAtA[i] = 0x18
    67  	}
    68  	if len(m.Shard) > 0 {
    69  		i -= len(m.Shard)
    70  		copy(dAtA[i:], m.Shard)
    71  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
    72  		i--
    73  		dAtA[i] = 0x12
    74  	}
    75  	if len(m.Keyspace) > 0 {
    76  		i -= len(m.Keyspace)
    77  		copy(dAtA[i:], m.Keyspace)
    78  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
    79  		i--
    80  		dAtA[i] = 0xa
    81  	}
    82  	return len(dAtA) - i, nil
    83  }
    84  
    85  func (m *VTGateCallerID) MarshalVT() (dAtA []byte, err error) {
    86  	if m == nil {
    87  		return nil, nil
    88  	}
    89  	size := m.SizeVT()
    90  	dAtA = make([]byte, size)
    91  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  	return dAtA[:n], nil
    96  }
    97  
    98  func (m *VTGateCallerID) MarshalToVT(dAtA []byte) (int, error) {
    99  	size := m.SizeVT()
   100  	return m.MarshalToSizedBufferVT(dAtA[:size])
   101  }
   102  
   103  func (m *VTGateCallerID) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   104  	if m == nil {
   105  		return 0, nil
   106  	}
   107  	i := len(dAtA)
   108  	_ = i
   109  	var l int
   110  	_ = l
   111  	if m.unknownFields != nil {
   112  		i -= len(m.unknownFields)
   113  		copy(dAtA[i:], m.unknownFields)
   114  	}
   115  	if len(m.Groups) > 0 {
   116  		for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- {
   117  			i -= len(m.Groups[iNdEx])
   118  			copy(dAtA[i:], m.Groups[iNdEx])
   119  			i = encodeVarint(dAtA, i, uint64(len(m.Groups[iNdEx])))
   120  			i--
   121  			dAtA[i] = 0x12
   122  		}
   123  	}
   124  	if len(m.Username) > 0 {
   125  		i -= len(m.Username)
   126  		copy(dAtA[i:], m.Username)
   127  		i = encodeVarint(dAtA, i, uint64(len(m.Username)))
   128  		i--
   129  		dAtA[i] = 0xa
   130  	}
   131  	return len(dAtA) - i, nil
   132  }
   133  
   134  func (m *EventToken) MarshalVT() (dAtA []byte, err error) {
   135  	if m == nil {
   136  		return nil, nil
   137  	}
   138  	size := m.SizeVT()
   139  	dAtA = make([]byte, size)
   140  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   141  	if err != nil {
   142  		return nil, err
   143  	}
   144  	return dAtA[:n], nil
   145  }
   146  
   147  func (m *EventToken) MarshalToVT(dAtA []byte) (int, error) {
   148  	size := m.SizeVT()
   149  	return m.MarshalToSizedBufferVT(dAtA[:size])
   150  }
   151  
   152  func (m *EventToken) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   153  	if m == nil {
   154  		return 0, nil
   155  	}
   156  	i := len(dAtA)
   157  	_ = i
   158  	var l int
   159  	_ = l
   160  	if m.unknownFields != nil {
   161  		i -= len(m.unknownFields)
   162  		copy(dAtA[i:], m.unknownFields)
   163  	}
   164  	if len(m.Position) > 0 {
   165  		i -= len(m.Position)
   166  		copy(dAtA[i:], m.Position)
   167  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
   168  		i--
   169  		dAtA[i] = 0x1a
   170  	}
   171  	if len(m.Shard) > 0 {
   172  		i -= len(m.Shard)
   173  		copy(dAtA[i:], m.Shard)
   174  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
   175  		i--
   176  		dAtA[i] = 0x12
   177  	}
   178  	if m.Timestamp != 0 {
   179  		i = encodeVarint(dAtA, i, uint64(m.Timestamp))
   180  		i--
   181  		dAtA[i] = 0x8
   182  	}
   183  	return len(dAtA) - i, nil
   184  }
   185  
   186  func (m *Value) MarshalVT() (dAtA []byte, err error) {
   187  	if m == nil {
   188  		return nil, nil
   189  	}
   190  	size := m.SizeVT()
   191  	dAtA = make([]byte, size)
   192  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   193  	if err != nil {
   194  		return nil, err
   195  	}
   196  	return dAtA[:n], nil
   197  }
   198  
   199  func (m *Value) MarshalToVT(dAtA []byte) (int, error) {
   200  	size := m.SizeVT()
   201  	return m.MarshalToSizedBufferVT(dAtA[:size])
   202  }
   203  
   204  func (m *Value) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   205  	if m == nil {
   206  		return 0, nil
   207  	}
   208  	i := len(dAtA)
   209  	_ = i
   210  	var l int
   211  	_ = l
   212  	if m.unknownFields != nil {
   213  		i -= len(m.unknownFields)
   214  		copy(dAtA[i:], m.unknownFields)
   215  	}
   216  	if len(m.Value) > 0 {
   217  		i -= len(m.Value)
   218  		copy(dAtA[i:], m.Value)
   219  		i = encodeVarint(dAtA, i, uint64(len(m.Value)))
   220  		i--
   221  		dAtA[i] = 0x12
   222  	}
   223  	if m.Type != 0 {
   224  		i = encodeVarint(dAtA, i, uint64(m.Type))
   225  		i--
   226  		dAtA[i] = 0x8
   227  	}
   228  	return len(dAtA) - i, nil
   229  }
   230  
   231  func (m *BindVariable) MarshalVT() (dAtA []byte, err error) {
   232  	if m == nil {
   233  		return nil, nil
   234  	}
   235  	size := m.SizeVT()
   236  	dAtA = make([]byte, size)
   237  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   238  	if err != nil {
   239  		return nil, err
   240  	}
   241  	return dAtA[:n], nil
   242  }
   243  
   244  func (m *BindVariable) MarshalToVT(dAtA []byte) (int, error) {
   245  	size := m.SizeVT()
   246  	return m.MarshalToSizedBufferVT(dAtA[:size])
   247  }
   248  
   249  func (m *BindVariable) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   250  	if m == nil {
   251  		return 0, nil
   252  	}
   253  	i := len(dAtA)
   254  	_ = i
   255  	var l int
   256  	_ = l
   257  	if m.unknownFields != nil {
   258  		i -= len(m.unknownFields)
   259  		copy(dAtA[i:], m.unknownFields)
   260  	}
   261  	if len(m.Values) > 0 {
   262  		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
   263  			size, err := m.Values[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   264  			if err != nil {
   265  				return 0, err
   266  			}
   267  			i -= size
   268  			i = encodeVarint(dAtA, i, uint64(size))
   269  			i--
   270  			dAtA[i] = 0x1a
   271  		}
   272  	}
   273  	if len(m.Value) > 0 {
   274  		i -= len(m.Value)
   275  		copy(dAtA[i:], m.Value)
   276  		i = encodeVarint(dAtA, i, uint64(len(m.Value)))
   277  		i--
   278  		dAtA[i] = 0x12
   279  	}
   280  	if m.Type != 0 {
   281  		i = encodeVarint(dAtA, i, uint64(m.Type))
   282  		i--
   283  		dAtA[i] = 0x8
   284  	}
   285  	return len(dAtA) - i, nil
   286  }
   287  
   288  func (m *BoundQuery) MarshalVT() (dAtA []byte, err error) {
   289  	if m == nil {
   290  		return nil, nil
   291  	}
   292  	size := m.SizeVT()
   293  	dAtA = make([]byte, size)
   294  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   295  	if err != nil {
   296  		return nil, err
   297  	}
   298  	return dAtA[:n], nil
   299  }
   300  
   301  func (m *BoundQuery) MarshalToVT(dAtA []byte) (int, error) {
   302  	size := m.SizeVT()
   303  	return m.MarshalToSizedBufferVT(dAtA[:size])
   304  }
   305  
   306  func (m *BoundQuery) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   307  	if m == nil {
   308  		return 0, nil
   309  	}
   310  	i := len(dAtA)
   311  	_ = i
   312  	var l int
   313  	_ = l
   314  	if m.unknownFields != nil {
   315  		i -= len(m.unknownFields)
   316  		copy(dAtA[i:], m.unknownFields)
   317  	}
   318  	if len(m.BindVariables) > 0 {
   319  		for k := range m.BindVariables {
   320  			v := m.BindVariables[k]
   321  			baseI := i
   322  			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
   323  			if err != nil {
   324  				return 0, err
   325  			}
   326  			i -= size
   327  			i = encodeVarint(dAtA, i, uint64(size))
   328  			i--
   329  			dAtA[i] = 0x12
   330  			i -= len(k)
   331  			copy(dAtA[i:], k)
   332  			i = encodeVarint(dAtA, i, uint64(len(k)))
   333  			i--
   334  			dAtA[i] = 0xa
   335  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   336  			i--
   337  			dAtA[i] = 0x12
   338  		}
   339  	}
   340  	if len(m.Sql) > 0 {
   341  		i -= len(m.Sql)
   342  		copy(dAtA[i:], m.Sql)
   343  		i = encodeVarint(dAtA, i, uint64(len(m.Sql)))
   344  		i--
   345  		dAtA[i] = 0xa
   346  	}
   347  	return len(dAtA) - i, nil
   348  }
   349  
   350  func (m *ExecuteOptions) MarshalVT() (dAtA []byte, err error) {
   351  	if m == nil {
   352  		return nil, nil
   353  	}
   354  	size := m.SizeVT()
   355  	dAtA = make([]byte, size)
   356  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   357  	if err != nil {
   358  		return nil, err
   359  	}
   360  	return dAtA[:n], nil
   361  }
   362  
   363  func (m *ExecuteOptions) MarshalToVT(dAtA []byte) (int, error) {
   364  	size := m.SizeVT()
   365  	return m.MarshalToSizedBufferVT(dAtA[:size])
   366  }
   367  
   368  func (m *ExecuteOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   369  	if m == nil {
   370  		return 0, nil
   371  	}
   372  	i := len(dAtA)
   373  	_ = i
   374  	var l int
   375  	_ = l
   376  	if m.unknownFields != nil {
   377  		i -= len(m.unknownFields)
   378  		copy(dAtA[i:], m.unknownFields)
   379  	}
   380  	if m.HasCreatedTempTables {
   381  		i--
   382  		if m.HasCreatedTempTables {
   383  			dAtA[i] = 1
   384  		} else {
   385  			dAtA[i] = 0
   386  		}
   387  		i--
   388  		dAtA[i] = 0x60
   389  	}
   390  	if m.PlannerVersion != 0 {
   391  		i = encodeVarint(dAtA, i, uint64(m.PlannerVersion))
   392  		i--
   393  		dAtA[i] = 0x58
   394  	}
   395  	if m.SkipQueryPlanCache {
   396  		i--
   397  		if m.SkipQueryPlanCache {
   398  			dAtA[i] = 1
   399  		} else {
   400  			dAtA[i] = 0
   401  		}
   402  		i--
   403  		dAtA[i] = 0x50
   404  	}
   405  	if m.TransactionIsolation != 0 {
   406  		i = encodeVarint(dAtA, i, uint64(m.TransactionIsolation))
   407  		i--
   408  		dAtA[i] = 0x48
   409  	}
   410  	if m.SqlSelectLimit != 0 {
   411  		i = encodeVarint(dAtA, i, uint64(m.SqlSelectLimit))
   412  		i--
   413  		dAtA[i] = 0x40
   414  	}
   415  	if m.Workload != 0 {
   416  		i = encodeVarint(dAtA, i, uint64(m.Workload))
   417  		i--
   418  		dAtA[i] = 0x30
   419  	}
   420  	if m.ClientFoundRows {
   421  		i--
   422  		if m.ClientFoundRows {
   423  			dAtA[i] = 1
   424  		} else {
   425  			dAtA[i] = 0
   426  		}
   427  		i--
   428  		dAtA[i] = 0x28
   429  	}
   430  	if m.IncludedFields != 0 {
   431  		i = encodeVarint(dAtA, i, uint64(m.IncludedFields))
   432  		i--
   433  		dAtA[i] = 0x20
   434  	}
   435  	return len(dAtA) - i, nil
   436  }
   437  
   438  func (m *Field) MarshalVT() (dAtA []byte, err error) {
   439  	if m == nil {
   440  		return nil, nil
   441  	}
   442  	size := m.SizeVT()
   443  	dAtA = make([]byte, size)
   444  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   445  	if err != nil {
   446  		return nil, err
   447  	}
   448  	return dAtA[:n], nil
   449  }
   450  
   451  func (m *Field) MarshalToVT(dAtA []byte) (int, error) {
   452  	size := m.SizeVT()
   453  	return m.MarshalToSizedBufferVT(dAtA[:size])
   454  }
   455  
   456  func (m *Field) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   457  	if m == nil {
   458  		return 0, nil
   459  	}
   460  	i := len(dAtA)
   461  	_ = i
   462  	var l int
   463  	_ = l
   464  	if m.unknownFields != nil {
   465  		i -= len(m.unknownFields)
   466  		copy(dAtA[i:], m.unknownFields)
   467  	}
   468  	if len(m.ColumnType) > 0 {
   469  		i -= len(m.ColumnType)
   470  		copy(dAtA[i:], m.ColumnType)
   471  		i = encodeVarint(dAtA, i, uint64(len(m.ColumnType)))
   472  		i--
   473  		dAtA[i] = 0x5a
   474  	}
   475  	if m.Flags != 0 {
   476  		i = encodeVarint(dAtA, i, uint64(m.Flags))
   477  		i--
   478  		dAtA[i] = 0x50
   479  	}
   480  	if m.Decimals != 0 {
   481  		i = encodeVarint(dAtA, i, uint64(m.Decimals))
   482  		i--
   483  		dAtA[i] = 0x48
   484  	}
   485  	if m.Charset != 0 {
   486  		i = encodeVarint(dAtA, i, uint64(m.Charset))
   487  		i--
   488  		dAtA[i] = 0x40
   489  	}
   490  	if m.ColumnLength != 0 {
   491  		i = encodeVarint(dAtA, i, uint64(m.ColumnLength))
   492  		i--
   493  		dAtA[i] = 0x38
   494  	}
   495  	if len(m.OrgName) > 0 {
   496  		i -= len(m.OrgName)
   497  		copy(dAtA[i:], m.OrgName)
   498  		i = encodeVarint(dAtA, i, uint64(len(m.OrgName)))
   499  		i--
   500  		dAtA[i] = 0x32
   501  	}
   502  	if len(m.Database) > 0 {
   503  		i -= len(m.Database)
   504  		copy(dAtA[i:], m.Database)
   505  		i = encodeVarint(dAtA, i, uint64(len(m.Database)))
   506  		i--
   507  		dAtA[i] = 0x2a
   508  	}
   509  	if len(m.OrgTable) > 0 {
   510  		i -= len(m.OrgTable)
   511  		copy(dAtA[i:], m.OrgTable)
   512  		i = encodeVarint(dAtA, i, uint64(len(m.OrgTable)))
   513  		i--
   514  		dAtA[i] = 0x22
   515  	}
   516  	if len(m.Table) > 0 {
   517  		i -= len(m.Table)
   518  		copy(dAtA[i:], m.Table)
   519  		i = encodeVarint(dAtA, i, uint64(len(m.Table)))
   520  		i--
   521  		dAtA[i] = 0x1a
   522  	}
   523  	if m.Type != 0 {
   524  		i = encodeVarint(dAtA, i, uint64(m.Type))
   525  		i--
   526  		dAtA[i] = 0x10
   527  	}
   528  	if len(m.Name) > 0 {
   529  		i -= len(m.Name)
   530  		copy(dAtA[i:], m.Name)
   531  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
   532  		i--
   533  		dAtA[i] = 0xa
   534  	}
   535  	return len(dAtA) - i, nil
   536  }
   537  
   538  func (m *Row) MarshalVT() (dAtA []byte, err error) {
   539  	if m == nil {
   540  		return nil, nil
   541  	}
   542  	size := m.SizeVT()
   543  	dAtA = make([]byte, size)
   544  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   545  	if err != nil {
   546  		return nil, err
   547  	}
   548  	return dAtA[:n], nil
   549  }
   550  
   551  func (m *Row) MarshalToVT(dAtA []byte) (int, error) {
   552  	size := m.SizeVT()
   553  	return m.MarshalToSizedBufferVT(dAtA[:size])
   554  }
   555  
   556  func (m *Row) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   557  	if m == nil {
   558  		return 0, nil
   559  	}
   560  	i := len(dAtA)
   561  	_ = i
   562  	var l int
   563  	_ = l
   564  	if m.unknownFields != nil {
   565  		i -= len(m.unknownFields)
   566  		copy(dAtA[i:], m.unknownFields)
   567  	}
   568  	if len(m.Values) > 0 {
   569  		i -= len(m.Values)
   570  		copy(dAtA[i:], m.Values)
   571  		i = encodeVarint(dAtA, i, uint64(len(m.Values)))
   572  		i--
   573  		dAtA[i] = 0x12
   574  	}
   575  	if len(m.Lengths) > 0 {
   576  		var pksize2 int
   577  		for _, num := range m.Lengths {
   578  			pksize2 += soz(uint64(num))
   579  		}
   580  		i -= pksize2
   581  		j1 := i
   582  		for _, num := range m.Lengths {
   583  			x3 := (uint64(num) << 1) ^ uint64((num >> 63))
   584  			for x3 >= 1<<7 {
   585  				dAtA[j1] = uint8(uint64(x3)&0x7f | 0x80)
   586  				j1++
   587  				x3 >>= 7
   588  			}
   589  			dAtA[j1] = uint8(x3)
   590  			j1++
   591  		}
   592  		i = encodeVarint(dAtA, i, uint64(pksize2))
   593  		i--
   594  		dAtA[i] = 0xa
   595  	}
   596  	return len(dAtA) - i, nil
   597  }
   598  
   599  func (m *QueryResult) MarshalVT() (dAtA []byte, err error) {
   600  	if m == nil {
   601  		return nil, nil
   602  	}
   603  	size := m.SizeVT()
   604  	dAtA = make([]byte, size)
   605  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   606  	if err != nil {
   607  		return nil, err
   608  	}
   609  	return dAtA[:n], nil
   610  }
   611  
   612  func (m *QueryResult) MarshalToVT(dAtA []byte) (int, error) {
   613  	size := m.SizeVT()
   614  	return m.MarshalToSizedBufferVT(dAtA[:size])
   615  }
   616  
   617  func (m *QueryResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   618  	if m == nil {
   619  		return 0, nil
   620  	}
   621  	i := len(dAtA)
   622  	_ = i
   623  	var l int
   624  	_ = l
   625  	if m.unknownFields != nil {
   626  		i -= len(m.unknownFields)
   627  		copy(dAtA[i:], m.unknownFields)
   628  	}
   629  	if len(m.Rows) > 0 {
   630  		for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- {
   631  			size, err := m.Rows[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   632  			if err != nil {
   633  				return 0, err
   634  			}
   635  			i -= size
   636  			i = encodeVarint(dAtA, i, uint64(size))
   637  			i--
   638  			dAtA[i] = 0x22
   639  		}
   640  	}
   641  	if m.InsertId != 0 {
   642  		i = encodeVarint(dAtA, i, uint64(m.InsertId))
   643  		i--
   644  		dAtA[i] = 0x18
   645  	}
   646  	if m.RowsAffected != 0 {
   647  		i = encodeVarint(dAtA, i, uint64(m.RowsAffected))
   648  		i--
   649  		dAtA[i] = 0x10
   650  	}
   651  	if len(m.Fields) > 0 {
   652  		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
   653  			size, err := m.Fields[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   654  			if err != nil {
   655  				return 0, err
   656  			}
   657  			i -= size
   658  			i = encodeVarint(dAtA, i, uint64(size))
   659  			i--
   660  			dAtA[i] = 0xa
   661  		}
   662  	}
   663  	return len(dAtA) - i, nil
   664  }
   665  
   666  func (m *QueryWarning) MarshalVT() (dAtA []byte, err error) {
   667  	if m == nil {
   668  		return nil, nil
   669  	}
   670  	size := m.SizeVT()
   671  	dAtA = make([]byte, size)
   672  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   673  	if err != nil {
   674  		return nil, err
   675  	}
   676  	return dAtA[:n], nil
   677  }
   678  
   679  func (m *QueryWarning) MarshalToVT(dAtA []byte) (int, error) {
   680  	size := m.SizeVT()
   681  	return m.MarshalToSizedBufferVT(dAtA[:size])
   682  }
   683  
   684  func (m *QueryWarning) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   685  	if m == nil {
   686  		return 0, nil
   687  	}
   688  	i := len(dAtA)
   689  	_ = i
   690  	var l int
   691  	_ = l
   692  	if m.unknownFields != nil {
   693  		i -= len(m.unknownFields)
   694  		copy(dAtA[i:], m.unknownFields)
   695  	}
   696  	if len(m.Message) > 0 {
   697  		i -= len(m.Message)
   698  		copy(dAtA[i:], m.Message)
   699  		i = encodeVarint(dAtA, i, uint64(len(m.Message)))
   700  		i--
   701  		dAtA[i] = 0x12
   702  	}
   703  	if m.Code != 0 {
   704  		i = encodeVarint(dAtA, i, uint64(m.Code))
   705  		i--
   706  		dAtA[i] = 0x8
   707  	}
   708  	return len(dAtA) - i, nil
   709  }
   710  
   711  func (m *StreamEvent_Statement) MarshalVT() (dAtA []byte, err error) {
   712  	if m == nil {
   713  		return nil, nil
   714  	}
   715  	size := m.SizeVT()
   716  	dAtA = make([]byte, size)
   717  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   718  	if err != nil {
   719  		return nil, err
   720  	}
   721  	return dAtA[:n], nil
   722  }
   723  
   724  func (m *StreamEvent_Statement) MarshalToVT(dAtA []byte) (int, error) {
   725  	size := m.SizeVT()
   726  	return m.MarshalToSizedBufferVT(dAtA[:size])
   727  }
   728  
   729  func (m *StreamEvent_Statement) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   730  	if m == nil {
   731  		return 0, nil
   732  	}
   733  	i := len(dAtA)
   734  	_ = i
   735  	var l int
   736  	_ = l
   737  	if m.unknownFields != nil {
   738  		i -= len(m.unknownFields)
   739  		copy(dAtA[i:], m.unknownFields)
   740  	}
   741  	if len(m.Sql) > 0 {
   742  		i -= len(m.Sql)
   743  		copy(dAtA[i:], m.Sql)
   744  		i = encodeVarint(dAtA, i, uint64(len(m.Sql)))
   745  		i--
   746  		dAtA[i] = 0x2a
   747  	}
   748  	if len(m.PrimaryKeyValues) > 0 {
   749  		for iNdEx := len(m.PrimaryKeyValues) - 1; iNdEx >= 0; iNdEx-- {
   750  			size, err := m.PrimaryKeyValues[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   751  			if err != nil {
   752  				return 0, err
   753  			}
   754  			i -= size
   755  			i = encodeVarint(dAtA, i, uint64(size))
   756  			i--
   757  			dAtA[i] = 0x22
   758  		}
   759  	}
   760  	if len(m.PrimaryKeyFields) > 0 {
   761  		for iNdEx := len(m.PrimaryKeyFields) - 1; iNdEx >= 0; iNdEx-- {
   762  			size, err := m.PrimaryKeyFields[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   763  			if err != nil {
   764  				return 0, err
   765  			}
   766  			i -= size
   767  			i = encodeVarint(dAtA, i, uint64(size))
   768  			i--
   769  			dAtA[i] = 0x1a
   770  		}
   771  	}
   772  	if len(m.TableName) > 0 {
   773  		i -= len(m.TableName)
   774  		copy(dAtA[i:], m.TableName)
   775  		i = encodeVarint(dAtA, i, uint64(len(m.TableName)))
   776  		i--
   777  		dAtA[i] = 0x12
   778  	}
   779  	if m.Category != 0 {
   780  		i = encodeVarint(dAtA, i, uint64(m.Category))
   781  		i--
   782  		dAtA[i] = 0x8
   783  	}
   784  	return len(dAtA) - i, nil
   785  }
   786  
   787  func (m *StreamEvent) MarshalVT() (dAtA []byte, err error) {
   788  	if m == nil {
   789  		return nil, nil
   790  	}
   791  	size := m.SizeVT()
   792  	dAtA = make([]byte, size)
   793  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   794  	if err != nil {
   795  		return nil, err
   796  	}
   797  	return dAtA[:n], nil
   798  }
   799  
   800  func (m *StreamEvent) MarshalToVT(dAtA []byte) (int, error) {
   801  	size := m.SizeVT()
   802  	return m.MarshalToSizedBufferVT(dAtA[:size])
   803  }
   804  
   805  func (m *StreamEvent) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   806  	if m == nil {
   807  		return 0, nil
   808  	}
   809  	i := len(dAtA)
   810  	_ = i
   811  	var l int
   812  	_ = l
   813  	if m.unknownFields != nil {
   814  		i -= len(m.unknownFields)
   815  		copy(dAtA[i:], m.unknownFields)
   816  	}
   817  	if m.EventToken != nil {
   818  		size, err := m.EventToken.MarshalToSizedBufferVT(dAtA[:i])
   819  		if err != nil {
   820  			return 0, err
   821  		}
   822  		i -= size
   823  		i = encodeVarint(dAtA, i, uint64(size))
   824  		i--
   825  		dAtA[i] = 0x12
   826  	}
   827  	if len(m.Statements) > 0 {
   828  		for iNdEx := len(m.Statements) - 1; iNdEx >= 0; iNdEx-- {
   829  			size, err := m.Statements[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   830  			if err != nil {
   831  				return 0, err
   832  			}
   833  			i -= size
   834  			i = encodeVarint(dAtA, i, uint64(size))
   835  			i--
   836  			dAtA[i] = 0xa
   837  		}
   838  	}
   839  	return len(dAtA) - i, nil
   840  }
   841  
   842  func (m *ExecuteRequest) MarshalVT() (dAtA []byte, err error) {
   843  	if m == nil {
   844  		return nil, nil
   845  	}
   846  	size := m.SizeVT()
   847  	dAtA = make([]byte, size)
   848  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   849  	if err != nil {
   850  		return nil, err
   851  	}
   852  	return dAtA[:n], nil
   853  }
   854  
   855  func (m *ExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
   856  	size := m.SizeVT()
   857  	return m.MarshalToSizedBufferVT(dAtA[:size])
   858  }
   859  
   860  func (m *ExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   861  	if m == nil {
   862  		return 0, nil
   863  	}
   864  	i := len(dAtA)
   865  	_ = i
   866  	var l int
   867  	_ = l
   868  	if m.unknownFields != nil {
   869  		i -= len(m.unknownFields)
   870  		copy(dAtA[i:], m.unknownFields)
   871  	}
   872  	if m.ReservedId != 0 {
   873  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
   874  		i--
   875  		dAtA[i] = 0x38
   876  	}
   877  	if m.Options != nil {
   878  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
   879  		if err != nil {
   880  			return 0, err
   881  		}
   882  		i -= size
   883  		i = encodeVarint(dAtA, i, uint64(size))
   884  		i--
   885  		dAtA[i] = 0x32
   886  	}
   887  	if m.TransactionId != 0 {
   888  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
   889  		i--
   890  		dAtA[i] = 0x28
   891  	}
   892  	if m.Query != nil {
   893  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
   894  		if err != nil {
   895  			return 0, err
   896  		}
   897  		i -= size
   898  		i = encodeVarint(dAtA, i, uint64(size))
   899  		i--
   900  		dAtA[i] = 0x22
   901  	}
   902  	if m.Target != nil {
   903  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
   904  		if err != nil {
   905  			return 0, err
   906  		}
   907  		i -= size
   908  		i = encodeVarint(dAtA, i, uint64(size))
   909  		i--
   910  		dAtA[i] = 0x1a
   911  	}
   912  	if m.ImmediateCallerId != nil {
   913  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
   914  		if err != nil {
   915  			return 0, err
   916  		}
   917  		i -= size
   918  		i = encodeVarint(dAtA, i, uint64(size))
   919  		i--
   920  		dAtA[i] = 0x12
   921  	}
   922  	if m.EffectiveCallerId != nil {
   923  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
   924  		if err != nil {
   925  			return 0, err
   926  		}
   927  		i -= size
   928  		i = encodeVarint(dAtA, i, uint64(size))
   929  		i--
   930  		dAtA[i] = 0xa
   931  	}
   932  	return len(dAtA) - i, nil
   933  }
   934  
   935  func (m *ExecuteResponse) MarshalVT() (dAtA []byte, err error) {
   936  	if m == nil {
   937  		return nil, nil
   938  	}
   939  	size := m.SizeVT()
   940  	dAtA = make([]byte, size)
   941  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   942  	if err != nil {
   943  		return nil, err
   944  	}
   945  	return dAtA[:n], nil
   946  }
   947  
   948  func (m *ExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
   949  	size := m.SizeVT()
   950  	return m.MarshalToSizedBufferVT(dAtA[:size])
   951  }
   952  
   953  func (m *ExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   954  	if m == nil {
   955  		return 0, nil
   956  	}
   957  	i := len(dAtA)
   958  	_ = i
   959  	var l int
   960  	_ = l
   961  	if m.unknownFields != nil {
   962  		i -= len(m.unknownFields)
   963  		copy(dAtA[i:], m.unknownFields)
   964  	}
   965  	if m.Result != nil {
   966  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
   967  		if err != nil {
   968  			return 0, err
   969  		}
   970  		i -= size
   971  		i = encodeVarint(dAtA, i, uint64(size))
   972  		i--
   973  		dAtA[i] = 0xa
   974  	}
   975  	return len(dAtA) - i, nil
   976  }
   977  
   978  func (m *ResultWithError) MarshalVT() (dAtA []byte, err error) {
   979  	if m == nil {
   980  		return nil, nil
   981  	}
   982  	size := m.SizeVT()
   983  	dAtA = make([]byte, size)
   984  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   985  	if err != nil {
   986  		return nil, err
   987  	}
   988  	return dAtA[:n], nil
   989  }
   990  
   991  func (m *ResultWithError) MarshalToVT(dAtA []byte) (int, error) {
   992  	size := m.SizeVT()
   993  	return m.MarshalToSizedBufferVT(dAtA[:size])
   994  }
   995  
   996  func (m *ResultWithError) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   997  	if m == nil {
   998  		return 0, nil
   999  	}
  1000  	i := len(dAtA)
  1001  	_ = i
  1002  	var l int
  1003  	_ = l
  1004  	if m.unknownFields != nil {
  1005  		i -= len(m.unknownFields)
  1006  		copy(dAtA[i:], m.unknownFields)
  1007  	}
  1008  	if m.Result != nil {
  1009  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  1010  		if err != nil {
  1011  			return 0, err
  1012  		}
  1013  		i -= size
  1014  		i = encodeVarint(dAtA, i, uint64(size))
  1015  		i--
  1016  		dAtA[i] = 0x12
  1017  	}
  1018  	if m.Error != nil {
  1019  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  1020  		if err != nil {
  1021  			return 0, err
  1022  		}
  1023  		i -= size
  1024  		i = encodeVarint(dAtA, i, uint64(size))
  1025  		i--
  1026  		dAtA[i] = 0xa
  1027  	}
  1028  	return len(dAtA) - i, nil
  1029  }
  1030  
  1031  func (m *StreamExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  1032  	if m == nil {
  1033  		return nil, nil
  1034  	}
  1035  	size := m.SizeVT()
  1036  	dAtA = make([]byte, size)
  1037  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1038  	if err != nil {
  1039  		return nil, err
  1040  	}
  1041  	return dAtA[:n], nil
  1042  }
  1043  
  1044  func (m *StreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  1045  	size := m.SizeVT()
  1046  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1047  }
  1048  
  1049  func (m *StreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1050  	if m == nil {
  1051  		return 0, nil
  1052  	}
  1053  	i := len(dAtA)
  1054  	_ = i
  1055  	var l int
  1056  	_ = l
  1057  	if m.unknownFields != nil {
  1058  		i -= len(m.unknownFields)
  1059  		copy(dAtA[i:], m.unknownFields)
  1060  	}
  1061  	if m.ReservedId != 0 {
  1062  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  1063  		i--
  1064  		dAtA[i] = 0x38
  1065  	}
  1066  	if m.TransactionId != 0 {
  1067  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1068  		i--
  1069  		dAtA[i] = 0x30
  1070  	}
  1071  	if m.Options != nil {
  1072  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1073  		if err != nil {
  1074  			return 0, err
  1075  		}
  1076  		i -= size
  1077  		i = encodeVarint(dAtA, i, uint64(size))
  1078  		i--
  1079  		dAtA[i] = 0x2a
  1080  	}
  1081  	if m.Query != nil {
  1082  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  1083  		if err != nil {
  1084  			return 0, err
  1085  		}
  1086  		i -= size
  1087  		i = encodeVarint(dAtA, i, uint64(size))
  1088  		i--
  1089  		dAtA[i] = 0x22
  1090  	}
  1091  	if m.Target != nil {
  1092  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1093  		if err != nil {
  1094  			return 0, err
  1095  		}
  1096  		i -= size
  1097  		i = encodeVarint(dAtA, i, uint64(size))
  1098  		i--
  1099  		dAtA[i] = 0x1a
  1100  	}
  1101  	if m.ImmediateCallerId != nil {
  1102  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1103  		if err != nil {
  1104  			return 0, err
  1105  		}
  1106  		i -= size
  1107  		i = encodeVarint(dAtA, i, uint64(size))
  1108  		i--
  1109  		dAtA[i] = 0x12
  1110  	}
  1111  	if m.EffectiveCallerId != nil {
  1112  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1113  		if err != nil {
  1114  			return 0, err
  1115  		}
  1116  		i -= size
  1117  		i = encodeVarint(dAtA, i, uint64(size))
  1118  		i--
  1119  		dAtA[i] = 0xa
  1120  	}
  1121  	return len(dAtA) - i, nil
  1122  }
  1123  
  1124  func (m *StreamExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  1125  	if m == nil {
  1126  		return nil, nil
  1127  	}
  1128  	size := m.SizeVT()
  1129  	dAtA = make([]byte, size)
  1130  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1131  	if err != nil {
  1132  		return nil, err
  1133  	}
  1134  	return dAtA[:n], nil
  1135  }
  1136  
  1137  func (m *StreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  1138  	size := m.SizeVT()
  1139  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1140  }
  1141  
  1142  func (m *StreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1143  	if m == nil {
  1144  		return 0, nil
  1145  	}
  1146  	i := len(dAtA)
  1147  	_ = i
  1148  	var l int
  1149  	_ = l
  1150  	if m.unknownFields != nil {
  1151  		i -= len(m.unknownFields)
  1152  		copy(dAtA[i:], m.unknownFields)
  1153  	}
  1154  	if m.Result != nil {
  1155  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  1156  		if err != nil {
  1157  			return 0, err
  1158  		}
  1159  		i -= size
  1160  		i = encodeVarint(dAtA, i, uint64(size))
  1161  		i--
  1162  		dAtA[i] = 0xa
  1163  	}
  1164  	return len(dAtA) - i, nil
  1165  }
  1166  
  1167  func (m *BeginRequest) MarshalVT() (dAtA []byte, err error) {
  1168  	if m == nil {
  1169  		return nil, nil
  1170  	}
  1171  	size := m.SizeVT()
  1172  	dAtA = make([]byte, size)
  1173  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1174  	if err != nil {
  1175  		return nil, err
  1176  	}
  1177  	return dAtA[:n], nil
  1178  }
  1179  
  1180  func (m *BeginRequest) MarshalToVT(dAtA []byte) (int, error) {
  1181  	size := m.SizeVT()
  1182  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1183  }
  1184  
  1185  func (m *BeginRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1186  	if m == nil {
  1187  		return 0, nil
  1188  	}
  1189  	i := len(dAtA)
  1190  	_ = i
  1191  	var l int
  1192  	_ = l
  1193  	if m.unknownFields != nil {
  1194  		i -= len(m.unknownFields)
  1195  		copy(dAtA[i:], m.unknownFields)
  1196  	}
  1197  	if m.Options != nil {
  1198  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1199  		if err != nil {
  1200  			return 0, err
  1201  		}
  1202  		i -= size
  1203  		i = encodeVarint(dAtA, i, uint64(size))
  1204  		i--
  1205  		dAtA[i] = 0x22
  1206  	}
  1207  	if m.Target != nil {
  1208  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1209  		if err != nil {
  1210  			return 0, err
  1211  		}
  1212  		i -= size
  1213  		i = encodeVarint(dAtA, i, uint64(size))
  1214  		i--
  1215  		dAtA[i] = 0x1a
  1216  	}
  1217  	if m.ImmediateCallerId != nil {
  1218  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1219  		if err != nil {
  1220  			return 0, err
  1221  		}
  1222  		i -= size
  1223  		i = encodeVarint(dAtA, i, uint64(size))
  1224  		i--
  1225  		dAtA[i] = 0x12
  1226  	}
  1227  	if m.EffectiveCallerId != nil {
  1228  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1229  		if err != nil {
  1230  			return 0, err
  1231  		}
  1232  		i -= size
  1233  		i = encodeVarint(dAtA, i, uint64(size))
  1234  		i--
  1235  		dAtA[i] = 0xa
  1236  	}
  1237  	return len(dAtA) - i, nil
  1238  }
  1239  
  1240  func (m *BeginResponse) MarshalVT() (dAtA []byte, err error) {
  1241  	if m == nil {
  1242  		return nil, nil
  1243  	}
  1244  	size := m.SizeVT()
  1245  	dAtA = make([]byte, size)
  1246  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1247  	if err != nil {
  1248  		return nil, err
  1249  	}
  1250  	return dAtA[:n], nil
  1251  }
  1252  
  1253  func (m *BeginResponse) MarshalToVT(dAtA []byte) (int, error) {
  1254  	size := m.SizeVT()
  1255  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1256  }
  1257  
  1258  func (m *BeginResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1259  	if m == nil {
  1260  		return 0, nil
  1261  	}
  1262  	i := len(dAtA)
  1263  	_ = i
  1264  	var l int
  1265  	_ = l
  1266  	if m.unknownFields != nil {
  1267  		i -= len(m.unknownFields)
  1268  		copy(dAtA[i:], m.unknownFields)
  1269  	}
  1270  	if m.TabletAlias != nil {
  1271  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  1272  		if err != nil {
  1273  			return 0, err
  1274  		}
  1275  		i -= size
  1276  		i = encodeVarint(dAtA, i, uint64(size))
  1277  		i--
  1278  		dAtA[i] = 0x12
  1279  	}
  1280  	if m.TransactionId != 0 {
  1281  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1282  		i--
  1283  		dAtA[i] = 0x8
  1284  	}
  1285  	return len(dAtA) - i, nil
  1286  }
  1287  
  1288  func (m *CommitRequest) MarshalVT() (dAtA []byte, err error) {
  1289  	if m == nil {
  1290  		return nil, nil
  1291  	}
  1292  	size := m.SizeVT()
  1293  	dAtA = make([]byte, size)
  1294  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1295  	if err != nil {
  1296  		return nil, err
  1297  	}
  1298  	return dAtA[:n], nil
  1299  }
  1300  
  1301  func (m *CommitRequest) MarshalToVT(dAtA []byte) (int, error) {
  1302  	size := m.SizeVT()
  1303  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1304  }
  1305  
  1306  func (m *CommitRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1307  	if m == nil {
  1308  		return 0, nil
  1309  	}
  1310  	i := len(dAtA)
  1311  	_ = i
  1312  	var l int
  1313  	_ = l
  1314  	if m.unknownFields != nil {
  1315  		i -= len(m.unknownFields)
  1316  		copy(dAtA[i:], m.unknownFields)
  1317  	}
  1318  	if m.TransactionId != 0 {
  1319  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1320  		i--
  1321  		dAtA[i] = 0x20
  1322  	}
  1323  	if m.Target != nil {
  1324  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1325  		if err != nil {
  1326  			return 0, err
  1327  		}
  1328  		i -= size
  1329  		i = encodeVarint(dAtA, i, uint64(size))
  1330  		i--
  1331  		dAtA[i] = 0x1a
  1332  	}
  1333  	if m.ImmediateCallerId != nil {
  1334  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1335  		if err != nil {
  1336  			return 0, err
  1337  		}
  1338  		i -= size
  1339  		i = encodeVarint(dAtA, i, uint64(size))
  1340  		i--
  1341  		dAtA[i] = 0x12
  1342  	}
  1343  	if m.EffectiveCallerId != nil {
  1344  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1345  		if err != nil {
  1346  			return 0, err
  1347  		}
  1348  		i -= size
  1349  		i = encodeVarint(dAtA, i, uint64(size))
  1350  		i--
  1351  		dAtA[i] = 0xa
  1352  	}
  1353  	return len(dAtA) - i, nil
  1354  }
  1355  
  1356  func (m *CommitResponse) MarshalVT() (dAtA []byte, err error) {
  1357  	if m == nil {
  1358  		return nil, nil
  1359  	}
  1360  	size := m.SizeVT()
  1361  	dAtA = make([]byte, size)
  1362  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1363  	if err != nil {
  1364  		return nil, err
  1365  	}
  1366  	return dAtA[:n], nil
  1367  }
  1368  
  1369  func (m *CommitResponse) MarshalToVT(dAtA []byte) (int, error) {
  1370  	size := m.SizeVT()
  1371  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1372  }
  1373  
  1374  func (m *CommitResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1375  	if m == nil {
  1376  		return 0, nil
  1377  	}
  1378  	i := len(dAtA)
  1379  	_ = i
  1380  	var l int
  1381  	_ = l
  1382  	if m.unknownFields != nil {
  1383  		i -= len(m.unknownFields)
  1384  		copy(dAtA[i:], m.unknownFields)
  1385  	}
  1386  	if m.ReservedId != 0 {
  1387  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  1388  		i--
  1389  		dAtA[i] = 0x8
  1390  	}
  1391  	return len(dAtA) - i, nil
  1392  }
  1393  
  1394  func (m *RollbackRequest) MarshalVT() (dAtA []byte, err error) {
  1395  	if m == nil {
  1396  		return nil, nil
  1397  	}
  1398  	size := m.SizeVT()
  1399  	dAtA = make([]byte, size)
  1400  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1401  	if err != nil {
  1402  		return nil, err
  1403  	}
  1404  	return dAtA[:n], nil
  1405  }
  1406  
  1407  func (m *RollbackRequest) MarshalToVT(dAtA []byte) (int, error) {
  1408  	size := m.SizeVT()
  1409  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1410  }
  1411  
  1412  func (m *RollbackRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1413  	if m == nil {
  1414  		return 0, nil
  1415  	}
  1416  	i := len(dAtA)
  1417  	_ = i
  1418  	var l int
  1419  	_ = l
  1420  	if m.unknownFields != nil {
  1421  		i -= len(m.unknownFields)
  1422  		copy(dAtA[i:], m.unknownFields)
  1423  	}
  1424  	if m.TransactionId != 0 {
  1425  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1426  		i--
  1427  		dAtA[i] = 0x20
  1428  	}
  1429  	if m.Target != nil {
  1430  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1431  		if err != nil {
  1432  			return 0, err
  1433  		}
  1434  		i -= size
  1435  		i = encodeVarint(dAtA, i, uint64(size))
  1436  		i--
  1437  		dAtA[i] = 0x1a
  1438  	}
  1439  	if m.ImmediateCallerId != nil {
  1440  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1441  		if err != nil {
  1442  			return 0, err
  1443  		}
  1444  		i -= size
  1445  		i = encodeVarint(dAtA, i, uint64(size))
  1446  		i--
  1447  		dAtA[i] = 0x12
  1448  	}
  1449  	if m.EffectiveCallerId != nil {
  1450  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1451  		if err != nil {
  1452  			return 0, err
  1453  		}
  1454  		i -= size
  1455  		i = encodeVarint(dAtA, i, uint64(size))
  1456  		i--
  1457  		dAtA[i] = 0xa
  1458  	}
  1459  	return len(dAtA) - i, nil
  1460  }
  1461  
  1462  func (m *RollbackResponse) MarshalVT() (dAtA []byte, err error) {
  1463  	if m == nil {
  1464  		return nil, nil
  1465  	}
  1466  	size := m.SizeVT()
  1467  	dAtA = make([]byte, size)
  1468  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1469  	if err != nil {
  1470  		return nil, err
  1471  	}
  1472  	return dAtA[:n], nil
  1473  }
  1474  
  1475  func (m *RollbackResponse) MarshalToVT(dAtA []byte) (int, error) {
  1476  	size := m.SizeVT()
  1477  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1478  }
  1479  
  1480  func (m *RollbackResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1481  	if m == nil {
  1482  		return 0, nil
  1483  	}
  1484  	i := len(dAtA)
  1485  	_ = i
  1486  	var l int
  1487  	_ = l
  1488  	if m.unknownFields != nil {
  1489  		i -= len(m.unknownFields)
  1490  		copy(dAtA[i:], m.unknownFields)
  1491  	}
  1492  	if m.ReservedId != 0 {
  1493  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  1494  		i--
  1495  		dAtA[i] = 0x8
  1496  	}
  1497  	return len(dAtA) - i, nil
  1498  }
  1499  
  1500  func (m *PrepareRequest) MarshalVT() (dAtA []byte, err error) {
  1501  	if m == nil {
  1502  		return nil, nil
  1503  	}
  1504  	size := m.SizeVT()
  1505  	dAtA = make([]byte, size)
  1506  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1507  	if err != nil {
  1508  		return nil, err
  1509  	}
  1510  	return dAtA[:n], nil
  1511  }
  1512  
  1513  func (m *PrepareRequest) MarshalToVT(dAtA []byte) (int, error) {
  1514  	size := m.SizeVT()
  1515  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1516  }
  1517  
  1518  func (m *PrepareRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1519  	if m == nil {
  1520  		return 0, nil
  1521  	}
  1522  	i := len(dAtA)
  1523  	_ = i
  1524  	var l int
  1525  	_ = l
  1526  	if m.unknownFields != nil {
  1527  		i -= len(m.unknownFields)
  1528  		copy(dAtA[i:], m.unknownFields)
  1529  	}
  1530  	if len(m.Dtid) > 0 {
  1531  		i -= len(m.Dtid)
  1532  		copy(dAtA[i:], m.Dtid)
  1533  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  1534  		i--
  1535  		dAtA[i] = 0x2a
  1536  	}
  1537  	if m.TransactionId != 0 {
  1538  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1539  		i--
  1540  		dAtA[i] = 0x20
  1541  	}
  1542  	if m.Target != nil {
  1543  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1544  		if err != nil {
  1545  			return 0, err
  1546  		}
  1547  		i -= size
  1548  		i = encodeVarint(dAtA, i, uint64(size))
  1549  		i--
  1550  		dAtA[i] = 0x1a
  1551  	}
  1552  	if m.ImmediateCallerId != nil {
  1553  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1554  		if err != nil {
  1555  			return 0, err
  1556  		}
  1557  		i -= size
  1558  		i = encodeVarint(dAtA, i, uint64(size))
  1559  		i--
  1560  		dAtA[i] = 0x12
  1561  	}
  1562  	if m.EffectiveCallerId != nil {
  1563  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1564  		if err != nil {
  1565  			return 0, err
  1566  		}
  1567  		i -= size
  1568  		i = encodeVarint(dAtA, i, uint64(size))
  1569  		i--
  1570  		dAtA[i] = 0xa
  1571  	}
  1572  	return len(dAtA) - i, nil
  1573  }
  1574  
  1575  func (m *PrepareResponse) MarshalVT() (dAtA []byte, err error) {
  1576  	if m == nil {
  1577  		return nil, nil
  1578  	}
  1579  	size := m.SizeVT()
  1580  	dAtA = make([]byte, size)
  1581  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1582  	if err != nil {
  1583  		return nil, err
  1584  	}
  1585  	return dAtA[:n], nil
  1586  }
  1587  
  1588  func (m *PrepareResponse) MarshalToVT(dAtA []byte) (int, error) {
  1589  	size := m.SizeVT()
  1590  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1591  }
  1592  
  1593  func (m *PrepareResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1594  	if m == nil {
  1595  		return 0, nil
  1596  	}
  1597  	i := len(dAtA)
  1598  	_ = i
  1599  	var l int
  1600  	_ = l
  1601  	if m.unknownFields != nil {
  1602  		i -= len(m.unknownFields)
  1603  		copy(dAtA[i:], m.unknownFields)
  1604  	}
  1605  	return len(dAtA) - i, nil
  1606  }
  1607  
  1608  func (m *CommitPreparedRequest) MarshalVT() (dAtA []byte, err error) {
  1609  	if m == nil {
  1610  		return nil, nil
  1611  	}
  1612  	size := m.SizeVT()
  1613  	dAtA = make([]byte, size)
  1614  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1615  	if err != nil {
  1616  		return nil, err
  1617  	}
  1618  	return dAtA[:n], nil
  1619  }
  1620  
  1621  func (m *CommitPreparedRequest) MarshalToVT(dAtA []byte) (int, error) {
  1622  	size := m.SizeVT()
  1623  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1624  }
  1625  
  1626  func (m *CommitPreparedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1627  	if m == nil {
  1628  		return 0, nil
  1629  	}
  1630  	i := len(dAtA)
  1631  	_ = i
  1632  	var l int
  1633  	_ = l
  1634  	if m.unknownFields != nil {
  1635  		i -= len(m.unknownFields)
  1636  		copy(dAtA[i:], m.unknownFields)
  1637  	}
  1638  	if len(m.Dtid) > 0 {
  1639  		i -= len(m.Dtid)
  1640  		copy(dAtA[i:], m.Dtid)
  1641  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  1642  		i--
  1643  		dAtA[i] = 0x22
  1644  	}
  1645  	if m.Target != nil {
  1646  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1647  		if err != nil {
  1648  			return 0, err
  1649  		}
  1650  		i -= size
  1651  		i = encodeVarint(dAtA, i, uint64(size))
  1652  		i--
  1653  		dAtA[i] = 0x1a
  1654  	}
  1655  	if m.ImmediateCallerId != nil {
  1656  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1657  		if err != nil {
  1658  			return 0, err
  1659  		}
  1660  		i -= size
  1661  		i = encodeVarint(dAtA, i, uint64(size))
  1662  		i--
  1663  		dAtA[i] = 0x12
  1664  	}
  1665  	if m.EffectiveCallerId != nil {
  1666  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1667  		if err != nil {
  1668  			return 0, err
  1669  		}
  1670  		i -= size
  1671  		i = encodeVarint(dAtA, i, uint64(size))
  1672  		i--
  1673  		dAtA[i] = 0xa
  1674  	}
  1675  	return len(dAtA) - i, nil
  1676  }
  1677  
  1678  func (m *CommitPreparedResponse) MarshalVT() (dAtA []byte, err error) {
  1679  	if m == nil {
  1680  		return nil, nil
  1681  	}
  1682  	size := m.SizeVT()
  1683  	dAtA = make([]byte, size)
  1684  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1685  	if err != nil {
  1686  		return nil, err
  1687  	}
  1688  	return dAtA[:n], nil
  1689  }
  1690  
  1691  func (m *CommitPreparedResponse) MarshalToVT(dAtA []byte) (int, error) {
  1692  	size := m.SizeVT()
  1693  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1694  }
  1695  
  1696  func (m *CommitPreparedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1697  	if m == nil {
  1698  		return 0, nil
  1699  	}
  1700  	i := len(dAtA)
  1701  	_ = i
  1702  	var l int
  1703  	_ = l
  1704  	if m.unknownFields != nil {
  1705  		i -= len(m.unknownFields)
  1706  		copy(dAtA[i:], m.unknownFields)
  1707  	}
  1708  	return len(dAtA) - i, nil
  1709  }
  1710  
  1711  func (m *RollbackPreparedRequest) MarshalVT() (dAtA []byte, err error) {
  1712  	if m == nil {
  1713  		return nil, nil
  1714  	}
  1715  	size := m.SizeVT()
  1716  	dAtA = make([]byte, size)
  1717  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1718  	if err != nil {
  1719  		return nil, err
  1720  	}
  1721  	return dAtA[:n], nil
  1722  }
  1723  
  1724  func (m *RollbackPreparedRequest) MarshalToVT(dAtA []byte) (int, error) {
  1725  	size := m.SizeVT()
  1726  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1727  }
  1728  
  1729  func (m *RollbackPreparedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1730  	if m == nil {
  1731  		return 0, nil
  1732  	}
  1733  	i := len(dAtA)
  1734  	_ = i
  1735  	var l int
  1736  	_ = l
  1737  	if m.unknownFields != nil {
  1738  		i -= len(m.unknownFields)
  1739  		copy(dAtA[i:], m.unknownFields)
  1740  	}
  1741  	if len(m.Dtid) > 0 {
  1742  		i -= len(m.Dtid)
  1743  		copy(dAtA[i:], m.Dtid)
  1744  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  1745  		i--
  1746  		dAtA[i] = 0x2a
  1747  	}
  1748  	if m.TransactionId != 0 {
  1749  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1750  		i--
  1751  		dAtA[i] = 0x20
  1752  	}
  1753  	if m.Target != nil {
  1754  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1755  		if err != nil {
  1756  			return 0, err
  1757  		}
  1758  		i -= size
  1759  		i = encodeVarint(dAtA, i, uint64(size))
  1760  		i--
  1761  		dAtA[i] = 0x1a
  1762  	}
  1763  	if m.ImmediateCallerId != nil {
  1764  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1765  		if err != nil {
  1766  			return 0, err
  1767  		}
  1768  		i -= size
  1769  		i = encodeVarint(dAtA, i, uint64(size))
  1770  		i--
  1771  		dAtA[i] = 0x12
  1772  	}
  1773  	if m.EffectiveCallerId != nil {
  1774  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1775  		if err != nil {
  1776  			return 0, err
  1777  		}
  1778  		i -= size
  1779  		i = encodeVarint(dAtA, i, uint64(size))
  1780  		i--
  1781  		dAtA[i] = 0xa
  1782  	}
  1783  	return len(dAtA) - i, nil
  1784  }
  1785  
  1786  func (m *RollbackPreparedResponse) MarshalVT() (dAtA []byte, err error) {
  1787  	if m == nil {
  1788  		return nil, nil
  1789  	}
  1790  	size := m.SizeVT()
  1791  	dAtA = make([]byte, size)
  1792  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1793  	if err != nil {
  1794  		return nil, err
  1795  	}
  1796  	return dAtA[:n], nil
  1797  }
  1798  
  1799  func (m *RollbackPreparedResponse) MarshalToVT(dAtA []byte) (int, error) {
  1800  	size := m.SizeVT()
  1801  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1802  }
  1803  
  1804  func (m *RollbackPreparedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1805  	if m == nil {
  1806  		return 0, nil
  1807  	}
  1808  	i := len(dAtA)
  1809  	_ = i
  1810  	var l int
  1811  	_ = l
  1812  	if m.unknownFields != nil {
  1813  		i -= len(m.unknownFields)
  1814  		copy(dAtA[i:], m.unknownFields)
  1815  	}
  1816  	return len(dAtA) - i, nil
  1817  }
  1818  
  1819  func (m *CreateTransactionRequest) MarshalVT() (dAtA []byte, err error) {
  1820  	if m == nil {
  1821  		return nil, nil
  1822  	}
  1823  	size := m.SizeVT()
  1824  	dAtA = make([]byte, size)
  1825  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1826  	if err != nil {
  1827  		return nil, err
  1828  	}
  1829  	return dAtA[:n], nil
  1830  }
  1831  
  1832  func (m *CreateTransactionRequest) MarshalToVT(dAtA []byte) (int, error) {
  1833  	size := m.SizeVT()
  1834  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1835  }
  1836  
  1837  func (m *CreateTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1838  	if m == nil {
  1839  		return 0, nil
  1840  	}
  1841  	i := len(dAtA)
  1842  	_ = i
  1843  	var l int
  1844  	_ = l
  1845  	if m.unknownFields != nil {
  1846  		i -= len(m.unknownFields)
  1847  		copy(dAtA[i:], m.unknownFields)
  1848  	}
  1849  	if len(m.Participants) > 0 {
  1850  		for iNdEx := len(m.Participants) - 1; iNdEx >= 0; iNdEx-- {
  1851  			size, err := m.Participants[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1852  			if err != nil {
  1853  				return 0, err
  1854  			}
  1855  			i -= size
  1856  			i = encodeVarint(dAtA, i, uint64(size))
  1857  			i--
  1858  			dAtA[i] = 0x2a
  1859  		}
  1860  	}
  1861  	if len(m.Dtid) > 0 {
  1862  		i -= len(m.Dtid)
  1863  		copy(dAtA[i:], m.Dtid)
  1864  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  1865  		i--
  1866  		dAtA[i] = 0x22
  1867  	}
  1868  	if m.Target != nil {
  1869  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1870  		if err != nil {
  1871  			return 0, err
  1872  		}
  1873  		i -= size
  1874  		i = encodeVarint(dAtA, i, uint64(size))
  1875  		i--
  1876  		dAtA[i] = 0x1a
  1877  	}
  1878  	if m.ImmediateCallerId != nil {
  1879  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1880  		if err != nil {
  1881  			return 0, err
  1882  		}
  1883  		i -= size
  1884  		i = encodeVarint(dAtA, i, uint64(size))
  1885  		i--
  1886  		dAtA[i] = 0x12
  1887  	}
  1888  	if m.EffectiveCallerId != nil {
  1889  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1890  		if err != nil {
  1891  			return 0, err
  1892  		}
  1893  		i -= size
  1894  		i = encodeVarint(dAtA, i, uint64(size))
  1895  		i--
  1896  		dAtA[i] = 0xa
  1897  	}
  1898  	return len(dAtA) - i, nil
  1899  }
  1900  
  1901  func (m *CreateTransactionResponse) MarshalVT() (dAtA []byte, err error) {
  1902  	if m == nil {
  1903  		return nil, nil
  1904  	}
  1905  	size := m.SizeVT()
  1906  	dAtA = make([]byte, size)
  1907  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1908  	if err != nil {
  1909  		return nil, err
  1910  	}
  1911  	return dAtA[:n], nil
  1912  }
  1913  
  1914  func (m *CreateTransactionResponse) MarshalToVT(dAtA []byte) (int, error) {
  1915  	size := m.SizeVT()
  1916  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1917  }
  1918  
  1919  func (m *CreateTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1920  	if m == nil {
  1921  		return 0, nil
  1922  	}
  1923  	i := len(dAtA)
  1924  	_ = i
  1925  	var l int
  1926  	_ = l
  1927  	if m.unknownFields != nil {
  1928  		i -= len(m.unknownFields)
  1929  		copy(dAtA[i:], m.unknownFields)
  1930  	}
  1931  	return len(dAtA) - i, nil
  1932  }
  1933  
  1934  func (m *StartCommitRequest) MarshalVT() (dAtA []byte, err error) {
  1935  	if m == nil {
  1936  		return nil, nil
  1937  	}
  1938  	size := m.SizeVT()
  1939  	dAtA = make([]byte, size)
  1940  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1941  	if err != nil {
  1942  		return nil, err
  1943  	}
  1944  	return dAtA[:n], nil
  1945  }
  1946  
  1947  func (m *StartCommitRequest) MarshalToVT(dAtA []byte) (int, error) {
  1948  	size := m.SizeVT()
  1949  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1950  }
  1951  
  1952  func (m *StartCommitRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1953  	if m == nil {
  1954  		return 0, nil
  1955  	}
  1956  	i := len(dAtA)
  1957  	_ = i
  1958  	var l int
  1959  	_ = l
  1960  	if m.unknownFields != nil {
  1961  		i -= len(m.unknownFields)
  1962  		copy(dAtA[i:], m.unknownFields)
  1963  	}
  1964  	if len(m.Dtid) > 0 {
  1965  		i -= len(m.Dtid)
  1966  		copy(dAtA[i:], m.Dtid)
  1967  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  1968  		i--
  1969  		dAtA[i] = 0x2a
  1970  	}
  1971  	if m.TransactionId != 0 {
  1972  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  1973  		i--
  1974  		dAtA[i] = 0x20
  1975  	}
  1976  	if m.Target != nil {
  1977  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  1978  		if err != nil {
  1979  			return 0, err
  1980  		}
  1981  		i -= size
  1982  		i = encodeVarint(dAtA, i, uint64(size))
  1983  		i--
  1984  		dAtA[i] = 0x1a
  1985  	}
  1986  	if m.ImmediateCallerId != nil {
  1987  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1988  		if err != nil {
  1989  			return 0, err
  1990  		}
  1991  		i -= size
  1992  		i = encodeVarint(dAtA, i, uint64(size))
  1993  		i--
  1994  		dAtA[i] = 0x12
  1995  	}
  1996  	if m.EffectiveCallerId != nil {
  1997  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  1998  		if err != nil {
  1999  			return 0, err
  2000  		}
  2001  		i -= size
  2002  		i = encodeVarint(dAtA, i, uint64(size))
  2003  		i--
  2004  		dAtA[i] = 0xa
  2005  	}
  2006  	return len(dAtA) - i, nil
  2007  }
  2008  
  2009  func (m *StartCommitResponse) MarshalVT() (dAtA []byte, err error) {
  2010  	if m == nil {
  2011  		return nil, nil
  2012  	}
  2013  	size := m.SizeVT()
  2014  	dAtA = make([]byte, size)
  2015  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2016  	if err != nil {
  2017  		return nil, err
  2018  	}
  2019  	return dAtA[:n], nil
  2020  }
  2021  
  2022  func (m *StartCommitResponse) MarshalToVT(dAtA []byte) (int, error) {
  2023  	size := m.SizeVT()
  2024  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2025  }
  2026  
  2027  func (m *StartCommitResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2028  	if m == nil {
  2029  		return 0, nil
  2030  	}
  2031  	i := len(dAtA)
  2032  	_ = i
  2033  	var l int
  2034  	_ = l
  2035  	if m.unknownFields != nil {
  2036  		i -= len(m.unknownFields)
  2037  		copy(dAtA[i:], m.unknownFields)
  2038  	}
  2039  	return len(dAtA) - i, nil
  2040  }
  2041  
  2042  func (m *SetRollbackRequest) MarshalVT() (dAtA []byte, err error) {
  2043  	if m == nil {
  2044  		return nil, nil
  2045  	}
  2046  	size := m.SizeVT()
  2047  	dAtA = make([]byte, size)
  2048  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2049  	if err != nil {
  2050  		return nil, err
  2051  	}
  2052  	return dAtA[:n], nil
  2053  }
  2054  
  2055  func (m *SetRollbackRequest) MarshalToVT(dAtA []byte) (int, error) {
  2056  	size := m.SizeVT()
  2057  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2058  }
  2059  
  2060  func (m *SetRollbackRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2061  	if m == nil {
  2062  		return 0, nil
  2063  	}
  2064  	i := len(dAtA)
  2065  	_ = i
  2066  	var l int
  2067  	_ = l
  2068  	if m.unknownFields != nil {
  2069  		i -= len(m.unknownFields)
  2070  		copy(dAtA[i:], m.unknownFields)
  2071  	}
  2072  	if len(m.Dtid) > 0 {
  2073  		i -= len(m.Dtid)
  2074  		copy(dAtA[i:], m.Dtid)
  2075  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  2076  		i--
  2077  		dAtA[i] = 0x2a
  2078  	}
  2079  	if m.TransactionId != 0 {
  2080  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  2081  		i--
  2082  		dAtA[i] = 0x20
  2083  	}
  2084  	if m.Target != nil {
  2085  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2086  		if err != nil {
  2087  			return 0, err
  2088  		}
  2089  		i -= size
  2090  		i = encodeVarint(dAtA, i, uint64(size))
  2091  		i--
  2092  		dAtA[i] = 0x1a
  2093  	}
  2094  	if m.ImmediateCallerId != nil {
  2095  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2096  		if err != nil {
  2097  			return 0, err
  2098  		}
  2099  		i -= size
  2100  		i = encodeVarint(dAtA, i, uint64(size))
  2101  		i--
  2102  		dAtA[i] = 0x12
  2103  	}
  2104  	if m.EffectiveCallerId != nil {
  2105  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2106  		if err != nil {
  2107  			return 0, err
  2108  		}
  2109  		i -= size
  2110  		i = encodeVarint(dAtA, i, uint64(size))
  2111  		i--
  2112  		dAtA[i] = 0xa
  2113  	}
  2114  	return len(dAtA) - i, nil
  2115  }
  2116  
  2117  func (m *SetRollbackResponse) MarshalVT() (dAtA []byte, err error) {
  2118  	if m == nil {
  2119  		return nil, nil
  2120  	}
  2121  	size := m.SizeVT()
  2122  	dAtA = make([]byte, size)
  2123  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2124  	if err != nil {
  2125  		return nil, err
  2126  	}
  2127  	return dAtA[:n], nil
  2128  }
  2129  
  2130  func (m *SetRollbackResponse) MarshalToVT(dAtA []byte) (int, error) {
  2131  	size := m.SizeVT()
  2132  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2133  }
  2134  
  2135  func (m *SetRollbackResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2136  	if m == nil {
  2137  		return 0, nil
  2138  	}
  2139  	i := len(dAtA)
  2140  	_ = i
  2141  	var l int
  2142  	_ = l
  2143  	if m.unknownFields != nil {
  2144  		i -= len(m.unknownFields)
  2145  		copy(dAtA[i:], m.unknownFields)
  2146  	}
  2147  	return len(dAtA) - i, nil
  2148  }
  2149  
  2150  func (m *ConcludeTransactionRequest) MarshalVT() (dAtA []byte, err error) {
  2151  	if m == nil {
  2152  		return nil, nil
  2153  	}
  2154  	size := m.SizeVT()
  2155  	dAtA = make([]byte, size)
  2156  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2157  	if err != nil {
  2158  		return nil, err
  2159  	}
  2160  	return dAtA[:n], nil
  2161  }
  2162  
  2163  func (m *ConcludeTransactionRequest) MarshalToVT(dAtA []byte) (int, error) {
  2164  	size := m.SizeVT()
  2165  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2166  }
  2167  
  2168  func (m *ConcludeTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2169  	if m == nil {
  2170  		return 0, nil
  2171  	}
  2172  	i := len(dAtA)
  2173  	_ = i
  2174  	var l int
  2175  	_ = l
  2176  	if m.unknownFields != nil {
  2177  		i -= len(m.unknownFields)
  2178  		copy(dAtA[i:], m.unknownFields)
  2179  	}
  2180  	if len(m.Dtid) > 0 {
  2181  		i -= len(m.Dtid)
  2182  		copy(dAtA[i:], m.Dtid)
  2183  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  2184  		i--
  2185  		dAtA[i] = 0x22
  2186  	}
  2187  	if m.Target != nil {
  2188  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2189  		if err != nil {
  2190  			return 0, err
  2191  		}
  2192  		i -= size
  2193  		i = encodeVarint(dAtA, i, uint64(size))
  2194  		i--
  2195  		dAtA[i] = 0x1a
  2196  	}
  2197  	if m.ImmediateCallerId != nil {
  2198  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2199  		if err != nil {
  2200  			return 0, err
  2201  		}
  2202  		i -= size
  2203  		i = encodeVarint(dAtA, i, uint64(size))
  2204  		i--
  2205  		dAtA[i] = 0x12
  2206  	}
  2207  	if m.EffectiveCallerId != nil {
  2208  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2209  		if err != nil {
  2210  			return 0, err
  2211  		}
  2212  		i -= size
  2213  		i = encodeVarint(dAtA, i, uint64(size))
  2214  		i--
  2215  		dAtA[i] = 0xa
  2216  	}
  2217  	return len(dAtA) - i, nil
  2218  }
  2219  
  2220  func (m *ConcludeTransactionResponse) MarshalVT() (dAtA []byte, err error) {
  2221  	if m == nil {
  2222  		return nil, nil
  2223  	}
  2224  	size := m.SizeVT()
  2225  	dAtA = make([]byte, size)
  2226  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2227  	if err != nil {
  2228  		return nil, err
  2229  	}
  2230  	return dAtA[:n], nil
  2231  }
  2232  
  2233  func (m *ConcludeTransactionResponse) MarshalToVT(dAtA []byte) (int, error) {
  2234  	size := m.SizeVT()
  2235  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2236  }
  2237  
  2238  func (m *ConcludeTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2239  	if m == nil {
  2240  		return 0, nil
  2241  	}
  2242  	i := len(dAtA)
  2243  	_ = i
  2244  	var l int
  2245  	_ = l
  2246  	if m.unknownFields != nil {
  2247  		i -= len(m.unknownFields)
  2248  		copy(dAtA[i:], m.unknownFields)
  2249  	}
  2250  	return len(dAtA) - i, nil
  2251  }
  2252  
  2253  func (m *ReadTransactionRequest) MarshalVT() (dAtA []byte, err error) {
  2254  	if m == nil {
  2255  		return nil, nil
  2256  	}
  2257  	size := m.SizeVT()
  2258  	dAtA = make([]byte, size)
  2259  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2260  	if err != nil {
  2261  		return nil, err
  2262  	}
  2263  	return dAtA[:n], nil
  2264  }
  2265  
  2266  func (m *ReadTransactionRequest) MarshalToVT(dAtA []byte) (int, error) {
  2267  	size := m.SizeVT()
  2268  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2269  }
  2270  
  2271  func (m *ReadTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2272  	if m == nil {
  2273  		return 0, nil
  2274  	}
  2275  	i := len(dAtA)
  2276  	_ = i
  2277  	var l int
  2278  	_ = l
  2279  	if m.unknownFields != nil {
  2280  		i -= len(m.unknownFields)
  2281  		copy(dAtA[i:], m.unknownFields)
  2282  	}
  2283  	if len(m.Dtid) > 0 {
  2284  		i -= len(m.Dtid)
  2285  		copy(dAtA[i:], m.Dtid)
  2286  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  2287  		i--
  2288  		dAtA[i] = 0x22
  2289  	}
  2290  	if m.Target != nil {
  2291  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2292  		if err != nil {
  2293  			return 0, err
  2294  		}
  2295  		i -= size
  2296  		i = encodeVarint(dAtA, i, uint64(size))
  2297  		i--
  2298  		dAtA[i] = 0x1a
  2299  	}
  2300  	if m.ImmediateCallerId != nil {
  2301  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2302  		if err != nil {
  2303  			return 0, err
  2304  		}
  2305  		i -= size
  2306  		i = encodeVarint(dAtA, i, uint64(size))
  2307  		i--
  2308  		dAtA[i] = 0x12
  2309  	}
  2310  	if m.EffectiveCallerId != nil {
  2311  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2312  		if err != nil {
  2313  			return 0, err
  2314  		}
  2315  		i -= size
  2316  		i = encodeVarint(dAtA, i, uint64(size))
  2317  		i--
  2318  		dAtA[i] = 0xa
  2319  	}
  2320  	return len(dAtA) - i, nil
  2321  }
  2322  
  2323  func (m *ReadTransactionResponse) MarshalVT() (dAtA []byte, err error) {
  2324  	if m == nil {
  2325  		return nil, nil
  2326  	}
  2327  	size := m.SizeVT()
  2328  	dAtA = make([]byte, size)
  2329  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2330  	if err != nil {
  2331  		return nil, err
  2332  	}
  2333  	return dAtA[:n], nil
  2334  }
  2335  
  2336  func (m *ReadTransactionResponse) MarshalToVT(dAtA []byte) (int, error) {
  2337  	size := m.SizeVT()
  2338  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2339  }
  2340  
  2341  func (m *ReadTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2342  	if m == nil {
  2343  		return 0, nil
  2344  	}
  2345  	i := len(dAtA)
  2346  	_ = i
  2347  	var l int
  2348  	_ = l
  2349  	if m.unknownFields != nil {
  2350  		i -= len(m.unknownFields)
  2351  		copy(dAtA[i:], m.unknownFields)
  2352  	}
  2353  	if m.Metadata != nil {
  2354  		size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i])
  2355  		if err != nil {
  2356  			return 0, err
  2357  		}
  2358  		i -= size
  2359  		i = encodeVarint(dAtA, i, uint64(size))
  2360  		i--
  2361  		dAtA[i] = 0xa
  2362  	}
  2363  	return len(dAtA) - i, nil
  2364  }
  2365  
  2366  func (m *BeginExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  2367  	if m == nil {
  2368  		return nil, nil
  2369  	}
  2370  	size := m.SizeVT()
  2371  	dAtA = make([]byte, size)
  2372  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2373  	if err != nil {
  2374  		return nil, err
  2375  	}
  2376  	return dAtA[:n], nil
  2377  }
  2378  
  2379  func (m *BeginExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  2380  	size := m.SizeVT()
  2381  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2382  }
  2383  
  2384  func (m *BeginExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2385  	if m == nil {
  2386  		return 0, nil
  2387  	}
  2388  	i := len(dAtA)
  2389  	_ = i
  2390  	var l int
  2391  	_ = l
  2392  	if m.unknownFields != nil {
  2393  		i -= len(m.unknownFields)
  2394  		copy(dAtA[i:], m.unknownFields)
  2395  	}
  2396  	if len(m.PreQueries) > 0 {
  2397  		for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- {
  2398  			i -= len(m.PreQueries[iNdEx])
  2399  			copy(dAtA[i:], m.PreQueries[iNdEx])
  2400  			i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx])))
  2401  			i--
  2402  			dAtA[i] = 0x3a
  2403  		}
  2404  	}
  2405  	if m.ReservedId != 0 {
  2406  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  2407  		i--
  2408  		dAtA[i] = 0x30
  2409  	}
  2410  	if m.Options != nil {
  2411  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  2412  		if err != nil {
  2413  			return 0, err
  2414  		}
  2415  		i -= size
  2416  		i = encodeVarint(dAtA, i, uint64(size))
  2417  		i--
  2418  		dAtA[i] = 0x2a
  2419  	}
  2420  	if m.Query != nil {
  2421  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  2422  		if err != nil {
  2423  			return 0, err
  2424  		}
  2425  		i -= size
  2426  		i = encodeVarint(dAtA, i, uint64(size))
  2427  		i--
  2428  		dAtA[i] = 0x22
  2429  	}
  2430  	if m.Target != nil {
  2431  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2432  		if err != nil {
  2433  			return 0, err
  2434  		}
  2435  		i -= size
  2436  		i = encodeVarint(dAtA, i, uint64(size))
  2437  		i--
  2438  		dAtA[i] = 0x1a
  2439  	}
  2440  	if m.ImmediateCallerId != nil {
  2441  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2442  		if err != nil {
  2443  			return 0, err
  2444  		}
  2445  		i -= size
  2446  		i = encodeVarint(dAtA, i, uint64(size))
  2447  		i--
  2448  		dAtA[i] = 0x12
  2449  	}
  2450  	if m.EffectiveCallerId != nil {
  2451  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2452  		if err != nil {
  2453  			return 0, err
  2454  		}
  2455  		i -= size
  2456  		i = encodeVarint(dAtA, i, uint64(size))
  2457  		i--
  2458  		dAtA[i] = 0xa
  2459  	}
  2460  	return len(dAtA) - i, nil
  2461  }
  2462  
  2463  func (m *BeginExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  2464  	if m == nil {
  2465  		return nil, nil
  2466  	}
  2467  	size := m.SizeVT()
  2468  	dAtA = make([]byte, size)
  2469  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2470  	if err != nil {
  2471  		return nil, err
  2472  	}
  2473  	return dAtA[:n], nil
  2474  }
  2475  
  2476  func (m *BeginExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  2477  	size := m.SizeVT()
  2478  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2479  }
  2480  
  2481  func (m *BeginExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2482  	if m == nil {
  2483  		return 0, nil
  2484  	}
  2485  	i := len(dAtA)
  2486  	_ = i
  2487  	var l int
  2488  	_ = l
  2489  	if m.unknownFields != nil {
  2490  		i -= len(m.unknownFields)
  2491  		copy(dAtA[i:], m.unknownFields)
  2492  	}
  2493  	if m.TabletAlias != nil {
  2494  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  2495  		if err != nil {
  2496  			return 0, err
  2497  		}
  2498  		i -= size
  2499  		i = encodeVarint(dAtA, i, uint64(size))
  2500  		i--
  2501  		dAtA[i] = 0x22
  2502  	}
  2503  	if m.TransactionId != 0 {
  2504  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  2505  		i--
  2506  		dAtA[i] = 0x18
  2507  	}
  2508  	if m.Result != nil {
  2509  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  2510  		if err != nil {
  2511  			return 0, err
  2512  		}
  2513  		i -= size
  2514  		i = encodeVarint(dAtA, i, uint64(size))
  2515  		i--
  2516  		dAtA[i] = 0x12
  2517  	}
  2518  	if m.Error != nil {
  2519  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  2520  		if err != nil {
  2521  			return 0, err
  2522  		}
  2523  		i -= size
  2524  		i = encodeVarint(dAtA, i, uint64(size))
  2525  		i--
  2526  		dAtA[i] = 0xa
  2527  	}
  2528  	return len(dAtA) - i, nil
  2529  }
  2530  
  2531  func (m *BeginStreamExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  2532  	if m == nil {
  2533  		return nil, nil
  2534  	}
  2535  	size := m.SizeVT()
  2536  	dAtA = make([]byte, size)
  2537  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2538  	if err != nil {
  2539  		return nil, err
  2540  	}
  2541  	return dAtA[:n], nil
  2542  }
  2543  
  2544  func (m *BeginStreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  2545  	size := m.SizeVT()
  2546  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2547  }
  2548  
  2549  func (m *BeginStreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2550  	if m == nil {
  2551  		return 0, nil
  2552  	}
  2553  	i := len(dAtA)
  2554  	_ = i
  2555  	var l int
  2556  	_ = l
  2557  	if m.unknownFields != nil {
  2558  		i -= len(m.unknownFields)
  2559  		copy(dAtA[i:], m.unknownFields)
  2560  	}
  2561  	if m.ReservedId != 0 {
  2562  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  2563  		i--
  2564  		dAtA[i] = 0x38
  2565  	}
  2566  	if len(m.PreQueries) > 0 {
  2567  		for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- {
  2568  			i -= len(m.PreQueries[iNdEx])
  2569  			copy(dAtA[i:], m.PreQueries[iNdEx])
  2570  			i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx])))
  2571  			i--
  2572  			dAtA[i] = 0x32
  2573  		}
  2574  	}
  2575  	if m.Options != nil {
  2576  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  2577  		if err != nil {
  2578  			return 0, err
  2579  		}
  2580  		i -= size
  2581  		i = encodeVarint(dAtA, i, uint64(size))
  2582  		i--
  2583  		dAtA[i] = 0x2a
  2584  	}
  2585  	if m.Query != nil {
  2586  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  2587  		if err != nil {
  2588  			return 0, err
  2589  		}
  2590  		i -= size
  2591  		i = encodeVarint(dAtA, i, uint64(size))
  2592  		i--
  2593  		dAtA[i] = 0x22
  2594  	}
  2595  	if m.Target != nil {
  2596  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2597  		if err != nil {
  2598  			return 0, err
  2599  		}
  2600  		i -= size
  2601  		i = encodeVarint(dAtA, i, uint64(size))
  2602  		i--
  2603  		dAtA[i] = 0x1a
  2604  	}
  2605  	if m.ImmediateCallerId != nil {
  2606  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2607  		if err != nil {
  2608  			return 0, err
  2609  		}
  2610  		i -= size
  2611  		i = encodeVarint(dAtA, i, uint64(size))
  2612  		i--
  2613  		dAtA[i] = 0x12
  2614  	}
  2615  	if m.EffectiveCallerId != nil {
  2616  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2617  		if err != nil {
  2618  			return 0, err
  2619  		}
  2620  		i -= size
  2621  		i = encodeVarint(dAtA, i, uint64(size))
  2622  		i--
  2623  		dAtA[i] = 0xa
  2624  	}
  2625  	return len(dAtA) - i, nil
  2626  }
  2627  
  2628  func (m *BeginStreamExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  2629  	if m == nil {
  2630  		return nil, nil
  2631  	}
  2632  	size := m.SizeVT()
  2633  	dAtA = make([]byte, size)
  2634  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2635  	if err != nil {
  2636  		return nil, err
  2637  	}
  2638  	return dAtA[:n], nil
  2639  }
  2640  
  2641  func (m *BeginStreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  2642  	size := m.SizeVT()
  2643  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2644  }
  2645  
  2646  func (m *BeginStreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2647  	if m == nil {
  2648  		return 0, nil
  2649  	}
  2650  	i := len(dAtA)
  2651  	_ = i
  2652  	var l int
  2653  	_ = l
  2654  	if m.unknownFields != nil {
  2655  		i -= len(m.unknownFields)
  2656  		copy(dAtA[i:], m.unknownFields)
  2657  	}
  2658  	if m.TabletAlias != nil {
  2659  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  2660  		if err != nil {
  2661  			return 0, err
  2662  		}
  2663  		i -= size
  2664  		i = encodeVarint(dAtA, i, uint64(size))
  2665  		i--
  2666  		dAtA[i] = 0x22
  2667  	}
  2668  	if m.TransactionId != 0 {
  2669  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  2670  		i--
  2671  		dAtA[i] = 0x18
  2672  	}
  2673  	if m.Result != nil {
  2674  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  2675  		if err != nil {
  2676  			return 0, err
  2677  		}
  2678  		i -= size
  2679  		i = encodeVarint(dAtA, i, uint64(size))
  2680  		i--
  2681  		dAtA[i] = 0x12
  2682  	}
  2683  	if m.Error != nil {
  2684  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  2685  		if err != nil {
  2686  			return 0, err
  2687  		}
  2688  		i -= size
  2689  		i = encodeVarint(dAtA, i, uint64(size))
  2690  		i--
  2691  		dAtA[i] = 0xa
  2692  	}
  2693  	return len(dAtA) - i, nil
  2694  }
  2695  
  2696  func (m *MessageStreamRequest) MarshalVT() (dAtA []byte, err error) {
  2697  	if m == nil {
  2698  		return nil, nil
  2699  	}
  2700  	size := m.SizeVT()
  2701  	dAtA = make([]byte, size)
  2702  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2703  	if err != nil {
  2704  		return nil, err
  2705  	}
  2706  	return dAtA[:n], nil
  2707  }
  2708  
  2709  func (m *MessageStreamRequest) MarshalToVT(dAtA []byte) (int, error) {
  2710  	size := m.SizeVT()
  2711  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2712  }
  2713  
  2714  func (m *MessageStreamRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2715  	if m == nil {
  2716  		return 0, nil
  2717  	}
  2718  	i := len(dAtA)
  2719  	_ = i
  2720  	var l int
  2721  	_ = l
  2722  	if m.unknownFields != nil {
  2723  		i -= len(m.unknownFields)
  2724  		copy(dAtA[i:], m.unknownFields)
  2725  	}
  2726  	if len(m.Name) > 0 {
  2727  		i -= len(m.Name)
  2728  		copy(dAtA[i:], m.Name)
  2729  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
  2730  		i--
  2731  		dAtA[i] = 0x22
  2732  	}
  2733  	if m.Target != nil {
  2734  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2735  		if err != nil {
  2736  			return 0, err
  2737  		}
  2738  		i -= size
  2739  		i = encodeVarint(dAtA, i, uint64(size))
  2740  		i--
  2741  		dAtA[i] = 0x1a
  2742  	}
  2743  	if m.ImmediateCallerId != nil {
  2744  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2745  		if err != nil {
  2746  			return 0, err
  2747  		}
  2748  		i -= size
  2749  		i = encodeVarint(dAtA, i, uint64(size))
  2750  		i--
  2751  		dAtA[i] = 0x12
  2752  	}
  2753  	if m.EffectiveCallerId != nil {
  2754  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2755  		if err != nil {
  2756  			return 0, err
  2757  		}
  2758  		i -= size
  2759  		i = encodeVarint(dAtA, i, uint64(size))
  2760  		i--
  2761  		dAtA[i] = 0xa
  2762  	}
  2763  	return len(dAtA) - i, nil
  2764  }
  2765  
  2766  func (m *MessageStreamResponse) MarshalVT() (dAtA []byte, err error) {
  2767  	if m == nil {
  2768  		return nil, nil
  2769  	}
  2770  	size := m.SizeVT()
  2771  	dAtA = make([]byte, size)
  2772  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2773  	if err != nil {
  2774  		return nil, err
  2775  	}
  2776  	return dAtA[:n], nil
  2777  }
  2778  
  2779  func (m *MessageStreamResponse) MarshalToVT(dAtA []byte) (int, error) {
  2780  	size := m.SizeVT()
  2781  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2782  }
  2783  
  2784  func (m *MessageStreamResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2785  	if m == nil {
  2786  		return 0, nil
  2787  	}
  2788  	i := len(dAtA)
  2789  	_ = i
  2790  	var l int
  2791  	_ = l
  2792  	if m.unknownFields != nil {
  2793  		i -= len(m.unknownFields)
  2794  		copy(dAtA[i:], m.unknownFields)
  2795  	}
  2796  	if m.Result != nil {
  2797  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  2798  		if err != nil {
  2799  			return 0, err
  2800  		}
  2801  		i -= size
  2802  		i = encodeVarint(dAtA, i, uint64(size))
  2803  		i--
  2804  		dAtA[i] = 0xa
  2805  	}
  2806  	return len(dAtA) - i, nil
  2807  }
  2808  
  2809  func (m *MessageAckRequest) MarshalVT() (dAtA []byte, err error) {
  2810  	if m == nil {
  2811  		return nil, nil
  2812  	}
  2813  	size := m.SizeVT()
  2814  	dAtA = make([]byte, size)
  2815  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2816  	if err != nil {
  2817  		return nil, err
  2818  	}
  2819  	return dAtA[:n], nil
  2820  }
  2821  
  2822  func (m *MessageAckRequest) MarshalToVT(dAtA []byte) (int, error) {
  2823  	size := m.SizeVT()
  2824  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2825  }
  2826  
  2827  func (m *MessageAckRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2828  	if m == nil {
  2829  		return 0, nil
  2830  	}
  2831  	i := len(dAtA)
  2832  	_ = i
  2833  	var l int
  2834  	_ = l
  2835  	if m.unknownFields != nil {
  2836  		i -= len(m.unknownFields)
  2837  		copy(dAtA[i:], m.unknownFields)
  2838  	}
  2839  	if len(m.Ids) > 0 {
  2840  		for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- {
  2841  			size, err := m.Ids[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2842  			if err != nil {
  2843  				return 0, err
  2844  			}
  2845  			i -= size
  2846  			i = encodeVarint(dAtA, i, uint64(size))
  2847  			i--
  2848  			dAtA[i] = 0x2a
  2849  		}
  2850  	}
  2851  	if len(m.Name) > 0 {
  2852  		i -= len(m.Name)
  2853  		copy(dAtA[i:], m.Name)
  2854  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
  2855  		i--
  2856  		dAtA[i] = 0x22
  2857  	}
  2858  	if m.Target != nil {
  2859  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  2860  		if err != nil {
  2861  			return 0, err
  2862  		}
  2863  		i -= size
  2864  		i = encodeVarint(dAtA, i, uint64(size))
  2865  		i--
  2866  		dAtA[i] = 0x1a
  2867  	}
  2868  	if m.ImmediateCallerId != nil {
  2869  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2870  		if err != nil {
  2871  			return 0, err
  2872  		}
  2873  		i -= size
  2874  		i = encodeVarint(dAtA, i, uint64(size))
  2875  		i--
  2876  		dAtA[i] = 0x12
  2877  	}
  2878  	if m.EffectiveCallerId != nil {
  2879  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  2880  		if err != nil {
  2881  			return 0, err
  2882  		}
  2883  		i -= size
  2884  		i = encodeVarint(dAtA, i, uint64(size))
  2885  		i--
  2886  		dAtA[i] = 0xa
  2887  	}
  2888  	return len(dAtA) - i, nil
  2889  }
  2890  
  2891  func (m *MessageAckResponse) MarshalVT() (dAtA []byte, err error) {
  2892  	if m == nil {
  2893  		return nil, nil
  2894  	}
  2895  	size := m.SizeVT()
  2896  	dAtA = make([]byte, size)
  2897  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2898  	if err != nil {
  2899  		return nil, err
  2900  	}
  2901  	return dAtA[:n], nil
  2902  }
  2903  
  2904  func (m *MessageAckResponse) MarshalToVT(dAtA []byte) (int, error) {
  2905  	size := m.SizeVT()
  2906  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2907  }
  2908  
  2909  func (m *MessageAckResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2910  	if m == nil {
  2911  		return 0, nil
  2912  	}
  2913  	i := len(dAtA)
  2914  	_ = i
  2915  	var l int
  2916  	_ = l
  2917  	if m.unknownFields != nil {
  2918  		i -= len(m.unknownFields)
  2919  		copy(dAtA[i:], m.unknownFields)
  2920  	}
  2921  	if m.Result != nil {
  2922  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  2923  		if err != nil {
  2924  			return 0, err
  2925  		}
  2926  		i -= size
  2927  		i = encodeVarint(dAtA, i, uint64(size))
  2928  		i--
  2929  		dAtA[i] = 0xa
  2930  	}
  2931  	return len(dAtA) - i, nil
  2932  }
  2933  
  2934  func (m *ReserveExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  2935  	if m == nil {
  2936  		return nil, nil
  2937  	}
  2938  	size := m.SizeVT()
  2939  	dAtA = make([]byte, size)
  2940  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2941  	if err != nil {
  2942  		return nil, err
  2943  	}
  2944  	return dAtA[:n], nil
  2945  }
  2946  
  2947  func (m *ReserveExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  2948  	size := m.SizeVT()
  2949  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2950  }
  2951  
  2952  func (m *ReserveExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2953  	if m == nil {
  2954  		return 0, nil
  2955  	}
  2956  	i := len(dAtA)
  2957  	_ = i
  2958  	var l int
  2959  	_ = l
  2960  	if m.unknownFields != nil {
  2961  		i -= len(m.unknownFields)
  2962  		copy(dAtA[i:], m.unknownFields)
  2963  	}
  2964  	if len(m.PreQueries) > 0 {
  2965  		for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- {
  2966  			i -= len(m.PreQueries[iNdEx])
  2967  			copy(dAtA[i:], m.PreQueries[iNdEx])
  2968  			i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx])))
  2969  			i--
  2970  			dAtA[i] = 0x3a
  2971  		}
  2972  	}
  2973  	if m.Options != nil {
  2974  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  2975  		if err != nil {
  2976  			return 0, err
  2977  		}
  2978  		i -= size
  2979  		i = encodeVarint(dAtA, i, uint64(size))
  2980  		i--
  2981  		dAtA[i] = 0x32
  2982  	}
  2983  	if m.TransactionId != 0 {
  2984  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  2985  		i--
  2986  		dAtA[i] = 0x28
  2987  	}
  2988  	if m.Query != nil {
  2989  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  2990  		if err != nil {
  2991  			return 0, err
  2992  		}
  2993  		i -= size
  2994  		i = encodeVarint(dAtA, i, uint64(size))
  2995  		i--
  2996  		dAtA[i] = 0x22
  2997  	}
  2998  	if m.Target != nil {
  2999  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  3000  		if err != nil {
  3001  			return 0, err
  3002  		}
  3003  		i -= size
  3004  		i = encodeVarint(dAtA, i, uint64(size))
  3005  		i--
  3006  		dAtA[i] = 0x1a
  3007  	}
  3008  	if m.ImmediateCallerId != nil {
  3009  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3010  		if err != nil {
  3011  			return 0, err
  3012  		}
  3013  		i -= size
  3014  		i = encodeVarint(dAtA, i, uint64(size))
  3015  		i--
  3016  		dAtA[i] = 0x12
  3017  	}
  3018  	if m.EffectiveCallerId != nil {
  3019  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3020  		if err != nil {
  3021  			return 0, err
  3022  		}
  3023  		i -= size
  3024  		i = encodeVarint(dAtA, i, uint64(size))
  3025  		i--
  3026  		dAtA[i] = 0xa
  3027  	}
  3028  	return len(dAtA) - i, nil
  3029  }
  3030  
  3031  func (m *ReserveExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  3032  	if m == nil {
  3033  		return nil, nil
  3034  	}
  3035  	size := m.SizeVT()
  3036  	dAtA = make([]byte, size)
  3037  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3038  	if err != nil {
  3039  		return nil, err
  3040  	}
  3041  	return dAtA[:n], nil
  3042  }
  3043  
  3044  func (m *ReserveExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  3045  	size := m.SizeVT()
  3046  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3047  }
  3048  
  3049  func (m *ReserveExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3050  	if m == nil {
  3051  		return 0, nil
  3052  	}
  3053  	i := len(dAtA)
  3054  	_ = i
  3055  	var l int
  3056  	_ = l
  3057  	if m.unknownFields != nil {
  3058  		i -= len(m.unknownFields)
  3059  		copy(dAtA[i:], m.unknownFields)
  3060  	}
  3061  	if m.TabletAlias != nil {
  3062  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  3063  		if err != nil {
  3064  			return 0, err
  3065  		}
  3066  		i -= size
  3067  		i = encodeVarint(dAtA, i, uint64(size))
  3068  		i--
  3069  		dAtA[i] = 0x22
  3070  	}
  3071  	if m.ReservedId != 0 {
  3072  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  3073  		i--
  3074  		dAtA[i] = 0x18
  3075  	}
  3076  	if m.Result != nil {
  3077  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  3078  		if err != nil {
  3079  			return 0, err
  3080  		}
  3081  		i -= size
  3082  		i = encodeVarint(dAtA, i, uint64(size))
  3083  		i--
  3084  		dAtA[i] = 0x12
  3085  	}
  3086  	if m.Error != nil {
  3087  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  3088  		if err != nil {
  3089  			return 0, err
  3090  		}
  3091  		i -= size
  3092  		i = encodeVarint(dAtA, i, uint64(size))
  3093  		i--
  3094  		dAtA[i] = 0xa
  3095  	}
  3096  	return len(dAtA) - i, nil
  3097  }
  3098  
  3099  func (m *ReserveStreamExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  3100  	if m == nil {
  3101  		return nil, nil
  3102  	}
  3103  	size := m.SizeVT()
  3104  	dAtA = make([]byte, size)
  3105  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3106  	if err != nil {
  3107  		return nil, err
  3108  	}
  3109  	return dAtA[:n], nil
  3110  }
  3111  
  3112  func (m *ReserveStreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  3113  	size := m.SizeVT()
  3114  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3115  }
  3116  
  3117  func (m *ReserveStreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3118  	if m == nil {
  3119  		return 0, nil
  3120  	}
  3121  	i := len(dAtA)
  3122  	_ = i
  3123  	var l int
  3124  	_ = l
  3125  	if m.unknownFields != nil {
  3126  		i -= len(m.unknownFields)
  3127  		copy(dAtA[i:], m.unknownFields)
  3128  	}
  3129  	if len(m.PreQueries) > 0 {
  3130  		for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- {
  3131  			i -= len(m.PreQueries[iNdEx])
  3132  			copy(dAtA[i:], m.PreQueries[iNdEx])
  3133  			i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx])))
  3134  			i--
  3135  			dAtA[i] = 0x3a
  3136  		}
  3137  	}
  3138  	if m.TransactionId != 0 {
  3139  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  3140  		i--
  3141  		dAtA[i] = 0x30
  3142  	}
  3143  	if m.Options != nil {
  3144  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  3145  		if err != nil {
  3146  			return 0, err
  3147  		}
  3148  		i -= size
  3149  		i = encodeVarint(dAtA, i, uint64(size))
  3150  		i--
  3151  		dAtA[i] = 0x2a
  3152  	}
  3153  	if m.Query != nil {
  3154  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  3155  		if err != nil {
  3156  			return 0, err
  3157  		}
  3158  		i -= size
  3159  		i = encodeVarint(dAtA, i, uint64(size))
  3160  		i--
  3161  		dAtA[i] = 0x22
  3162  	}
  3163  	if m.Target != nil {
  3164  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  3165  		if err != nil {
  3166  			return 0, err
  3167  		}
  3168  		i -= size
  3169  		i = encodeVarint(dAtA, i, uint64(size))
  3170  		i--
  3171  		dAtA[i] = 0x1a
  3172  	}
  3173  	if m.ImmediateCallerId != nil {
  3174  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3175  		if err != nil {
  3176  			return 0, err
  3177  		}
  3178  		i -= size
  3179  		i = encodeVarint(dAtA, i, uint64(size))
  3180  		i--
  3181  		dAtA[i] = 0x12
  3182  	}
  3183  	if m.EffectiveCallerId != nil {
  3184  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3185  		if err != nil {
  3186  			return 0, err
  3187  		}
  3188  		i -= size
  3189  		i = encodeVarint(dAtA, i, uint64(size))
  3190  		i--
  3191  		dAtA[i] = 0xa
  3192  	}
  3193  	return len(dAtA) - i, nil
  3194  }
  3195  
  3196  func (m *ReserveStreamExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  3197  	if m == nil {
  3198  		return nil, nil
  3199  	}
  3200  	size := m.SizeVT()
  3201  	dAtA = make([]byte, size)
  3202  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3203  	if err != nil {
  3204  		return nil, err
  3205  	}
  3206  	return dAtA[:n], nil
  3207  }
  3208  
  3209  func (m *ReserveStreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  3210  	size := m.SizeVT()
  3211  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3212  }
  3213  
  3214  func (m *ReserveStreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3215  	if m == nil {
  3216  		return 0, nil
  3217  	}
  3218  	i := len(dAtA)
  3219  	_ = i
  3220  	var l int
  3221  	_ = l
  3222  	if m.unknownFields != nil {
  3223  		i -= len(m.unknownFields)
  3224  		copy(dAtA[i:], m.unknownFields)
  3225  	}
  3226  	if m.TabletAlias != nil {
  3227  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  3228  		if err != nil {
  3229  			return 0, err
  3230  		}
  3231  		i -= size
  3232  		i = encodeVarint(dAtA, i, uint64(size))
  3233  		i--
  3234  		dAtA[i] = 0x22
  3235  	}
  3236  	if m.ReservedId != 0 {
  3237  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  3238  		i--
  3239  		dAtA[i] = 0x18
  3240  	}
  3241  	if m.Result != nil {
  3242  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  3243  		if err != nil {
  3244  			return 0, err
  3245  		}
  3246  		i -= size
  3247  		i = encodeVarint(dAtA, i, uint64(size))
  3248  		i--
  3249  		dAtA[i] = 0x12
  3250  	}
  3251  	if m.Error != nil {
  3252  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  3253  		if err != nil {
  3254  			return 0, err
  3255  		}
  3256  		i -= size
  3257  		i = encodeVarint(dAtA, i, uint64(size))
  3258  		i--
  3259  		dAtA[i] = 0xa
  3260  	}
  3261  	return len(dAtA) - i, nil
  3262  }
  3263  
  3264  func (m *ReserveBeginExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  3265  	if m == nil {
  3266  		return nil, nil
  3267  	}
  3268  	size := m.SizeVT()
  3269  	dAtA = make([]byte, size)
  3270  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3271  	if err != nil {
  3272  		return nil, err
  3273  	}
  3274  	return dAtA[:n], nil
  3275  }
  3276  
  3277  func (m *ReserveBeginExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  3278  	size := m.SizeVT()
  3279  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3280  }
  3281  
  3282  func (m *ReserveBeginExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3283  	if m == nil {
  3284  		return 0, nil
  3285  	}
  3286  	i := len(dAtA)
  3287  	_ = i
  3288  	var l int
  3289  	_ = l
  3290  	if m.unknownFields != nil {
  3291  		i -= len(m.unknownFields)
  3292  		copy(dAtA[i:], m.unknownFields)
  3293  	}
  3294  	if len(m.PostBeginQueries) > 0 {
  3295  		for iNdEx := len(m.PostBeginQueries) - 1; iNdEx >= 0; iNdEx-- {
  3296  			i -= len(m.PostBeginQueries[iNdEx])
  3297  			copy(dAtA[i:], m.PostBeginQueries[iNdEx])
  3298  			i = encodeVarint(dAtA, i, uint64(len(m.PostBeginQueries[iNdEx])))
  3299  			i--
  3300  			dAtA[i] = 0x3a
  3301  		}
  3302  	}
  3303  	if len(m.PreQueries) > 0 {
  3304  		for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- {
  3305  			i -= len(m.PreQueries[iNdEx])
  3306  			copy(dAtA[i:], m.PreQueries[iNdEx])
  3307  			i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx])))
  3308  			i--
  3309  			dAtA[i] = 0x32
  3310  		}
  3311  	}
  3312  	if m.Options != nil {
  3313  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  3314  		if err != nil {
  3315  			return 0, err
  3316  		}
  3317  		i -= size
  3318  		i = encodeVarint(dAtA, i, uint64(size))
  3319  		i--
  3320  		dAtA[i] = 0x2a
  3321  	}
  3322  	if m.Query != nil {
  3323  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  3324  		if err != nil {
  3325  			return 0, err
  3326  		}
  3327  		i -= size
  3328  		i = encodeVarint(dAtA, i, uint64(size))
  3329  		i--
  3330  		dAtA[i] = 0x22
  3331  	}
  3332  	if m.Target != nil {
  3333  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  3334  		if err != nil {
  3335  			return 0, err
  3336  		}
  3337  		i -= size
  3338  		i = encodeVarint(dAtA, i, uint64(size))
  3339  		i--
  3340  		dAtA[i] = 0x1a
  3341  	}
  3342  	if m.ImmediateCallerId != nil {
  3343  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3344  		if err != nil {
  3345  			return 0, err
  3346  		}
  3347  		i -= size
  3348  		i = encodeVarint(dAtA, i, uint64(size))
  3349  		i--
  3350  		dAtA[i] = 0x12
  3351  	}
  3352  	if m.EffectiveCallerId != nil {
  3353  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3354  		if err != nil {
  3355  			return 0, err
  3356  		}
  3357  		i -= size
  3358  		i = encodeVarint(dAtA, i, uint64(size))
  3359  		i--
  3360  		dAtA[i] = 0xa
  3361  	}
  3362  	return len(dAtA) - i, nil
  3363  }
  3364  
  3365  func (m *ReserveBeginExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  3366  	if m == nil {
  3367  		return nil, nil
  3368  	}
  3369  	size := m.SizeVT()
  3370  	dAtA = make([]byte, size)
  3371  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3372  	if err != nil {
  3373  		return nil, err
  3374  	}
  3375  	return dAtA[:n], nil
  3376  }
  3377  
  3378  func (m *ReserveBeginExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  3379  	size := m.SizeVT()
  3380  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3381  }
  3382  
  3383  func (m *ReserveBeginExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3384  	if m == nil {
  3385  		return 0, nil
  3386  	}
  3387  	i := len(dAtA)
  3388  	_ = i
  3389  	var l int
  3390  	_ = l
  3391  	if m.unknownFields != nil {
  3392  		i -= len(m.unknownFields)
  3393  		copy(dAtA[i:], m.unknownFields)
  3394  	}
  3395  	if m.TabletAlias != nil {
  3396  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  3397  		if err != nil {
  3398  			return 0, err
  3399  		}
  3400  		i -= size
  3401  		i = encodeVarint(dAtA, i, uint64(size))
  3402  		i--
  3403  		dAtA[i] = 0x2a
  3404  	}
  3405  	if m.ReservedId != 0 {
  3406  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  3407  		i--
  3408  		dAtA[i] = 0x20
  3409  	}
  3410  	if m.TransactionId != 0 {
  3411  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  3412  		i--
  3413  		dAtA[i] = 0x18
  3414  	}
  3415  	if m.Result != nil {
  3416  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  3417  		if err != nil {
  3418  			return 0, err
  3419  		}
  3420  		i -= size
  3421  		i = encodeVarint(dAtA, i, uint64(size))
  3422  		i--
  3423  		dAtA[i] = 0x12
  3424  	}
  3425  	if m.Error != nil {
  3426  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  3427  		if err != nil {
  3428  			return 0, err
  3429  		}
  3430  		i -= size
  3431  		i = encodeVarint(dAtA, i, uint64(size))
  3432  		i--
  3433  		dAtA[i] = 0xa
  3434  	}
  3435  	return len(dAtA) - i, nil
  3436  }
  3437  
  3438  func (m *ReserveBeginStreamExecuteRequest) MarshalVT() (dAtA []byte, err error) {
  3439  	if m == nil {
  3440  		return nil, nil
  3441  	}
  3442  	size := m.SizeVT()
  3443  	dAtA = make([]byte, size)
  3444  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3445  	if err != nil {
  3446  		return nil, err
  3447  	}
  3448  	return dAtA[:n], nil
  3449  }
  3450  
  3451  func (m *ReserveBeginStreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) {
  3452  	size := m.SizeVT()
  3453  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3454  }
  3455  
  3456  func (m *ReserveBeginStreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3457  	if m == nil {
  3458  		return 0, nil
  3459  	}
  3460  	i := len(dAtA)
  3461  	_ = i
  3462  	var l int
  3463  	_ = l
  3464  	if m.unknownFields != nil {
  3465  		i -= len(m.unknownFields)
  3466  		copy(dAtA[i:], m.unknownFields)
  3467  	}
  3468  	if len(m.PostBeginQueries) > 0 {
  3469  		for iNdEx := len(m.PostBeginQueries) - 1; iNdEx >= 0; iNdEx-- {
  3470  			i -= len(m.PostBeginQueries[iNdEx])
  3471  			copy(dAtA[i:], m.PostBeginQueries[iNdEx])
  3472  			i = encodeVarint(dAtA, i, uint64(len(m.PostBeginQueries[iNdEx])))
  3473  			i--
  3474  			dAtA[i] = 0x3a
  3475  		}
  3476  	}
  3477  	if len(m.PreQueries) > 0 {
  3478  		for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- {
  3479  			i -= len(m.PreQueries[iNdEx])
  3480  			copy(dAtA[i:], m.PreQueries[iNdEx])
  3481  			i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx])))
  3482  			i--
  3483  			dAtA[i] = 0x32
  3484  		}
  3485  	}
  3486  	if m.Options != nil {
  3487  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  3488  		if err != nil {
  3489  			return 0, err
  3490  		}
  3491  		i -= size
  3492  		i = encodeVarint(dAtA, i, uint64(size))
  3493  		i--
  3494  		dAtA[i] = 0x2a
  3495  	}
  3496  	if m.Query != nil {
  3497  		size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i])
  3498  		if err != nil {
  3499  			return 0, err
  3500  		}
  3501  		i -= size
  3502  		i = encodeVarint(dAtA, i, uint64(size))
  3503  		i--
  3504  		dAtA[i] = 0x22
  3505  	}
  3506  	if m.Target != nil {
  3507  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  3508  		if err != nil {
  3509  			return 0, err
  3510  		}
  3511  		i -= size
  3512  		i = encodeVarint(dAtA, i, uint64(size))
  3513  		i--
  3514  		dAtA[i] = 0x1a
  3515  	}
  3516  	if m.ImmediateCallerId != nil {
  3517  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3518  		if err != nil {
  3519  			return 0, err
  3520  		}
  3521  		i -= size
  3522  		i = encodeVarint(dAtA, i, uint64(size))
  3523  		i--
  3524  		dAtA[i] = 0x12
  3525  	}
  3526  	if m.EffectiveCallerId != nil {
  3527  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3528  		if err != nil {
  3529  			return 0, err
  3530  		}
  3531  		i -= size
  3532  		i = encodeVarint(dAtA, i, uint64(size))
  3533  		i--
  3534  		dAtA[i] = 0xa
  3535  	}
  3536  	return len(dAtA) - i, nil
  3537  }
  3538  
  3539  func (m *ReserveBeginStreamExecuteResponse) MarshalVT() (dAtA []byte, err error) {
  3540  	if m == nil {
  3541  		return nil, nil
  3542  	}
  3543  	size := m.SizeVT()
  3544  	dAtA = make([]byte, size)
  3545  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3546  	if err != nil {
  3547  		return nil, err
  3548  	}
  3549  	return dAtA[:n], nil
  3550  }
  3551  
  3552  func (m *ReserveBeginStreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) {
  3553  	size := m.SizeVT()
  3554  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3555  }
  3556  
  3557  func (m *ReserveBeginStreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3558  	if m == nil {
  3559  		return 0, nil
  3560  	}
  3561  	i := len(dAtA)
  3562  	_ = i
  3563  	var l int
  3564  	_ = l
  3565  	if m.unknownFields != nil {
  3566  		i -= len(m.unknownFields)
  3567  		copy(dAtA[i:], m.unknownFields)
  3568  	}
  3569  	if m.TabletAlias != nil {
  3570  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  3571  		if err != nil {
  3572  			return 0, err
  3573  		}
  3574  		i -= size
  3575  		i = encodeVarint(dAtA, i, uint64(size))
  3576  		i--
  3577  		dAtA[i] = 0x2a
  3578  	}
  3579  	if m.ReservedId != 0 {
  3580  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  3581  		i--
  3582  		dAtA[i] = 0x20
  3583  	}
  3584  	if m.TransactionId != 0 {
  3585  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  3586  		i--
  3587  		dAtA[i] = 0x18
  3588  	}
  3589  	if m.Result != nil {
  3590  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  3591  		if err != nil {
  3592  			return 0, err
  3593  		}
  3594  		i -= size
  3595  		i = encodeVarint(dAtA, i, uint64(size))
  3596  		i--
  3597  		dAtA[i] = 0x12
  3598  	}
  3599  	if m.Error != nil {
  3600  		size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i])
  3601  		if err != nil {
  3602  			return 0, err
  3603  		}
  3604  		i -= size
  3605  		i = encodeVarint(dAtA, i, uint64(size))
  3606  		i--
  3607  		dAtA[i] = 0xa
  3608  	}
  3609  	return len(dAtA) - i, nil
  3610  }
  3611  
  3612  func (m *ReleaseRequest) MarshalVT() (dAtA []byte, err error) {
  3613  	if m == nil {
  3614  		return nil, nil
  3615  	}
  3616  	size := m.SizeVT()
  3617  	dAtA = make([]byte, size)
  3618  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3619  	if err != nil {
  3620  		return nil, err
  3621  	}
  3622  	return dAtA[:n], nil
  3623  }
  3624  
  3625  func (m *ReleaseRequest) MarshalToVT(dAtA []byte) (int, error) {
  3626  	size := m.SizeVT()
  3627  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3628  }
  3629  
  3630  func (m *ReleaseRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3631  	if m == nil {
  3632  		return 0, nil
  3633  	}
  3634  	i := len(dAtA)
  3635  	_ = i
  3636  	var l int
  3637  	_ = l
  3638  	if m.unknownFields != nil {
  3639  		i -= len(m.unknownFields)
  3640  		copy(dAtA[i:], m.unknownFields)
  3641  	}
  3642  	if m.ReservedId != 0 {
  3643  		i = encodeVarint(dAtA, i, uint64(m.ReservedId))
  3644  		i--
  3645  		dAtA[i] = 0x28
  3646  	}
  3647  	if m.TransactionId != 0 {
  3648  		i = encodeVarint(dAtA, i, uint64(m.TransactionId))
  3649  		i--
  3650  		dAtA[i] = 0x20
  3651  	}
  3652  	if m.Target != nil {
  3653  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  3654  		if err != nil {
  3655  			return 0, err
  3656  		}
  3657  		i -= size
  3658  		i = encodeVarint(dAtA, i, uint64(size))
  3659  		i--
  3660  		dAtA[i] = 0x1a
  3661  	}
  3662  	if m.ImmediateCallerId != nil {
  3663  		size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3664  		if err != nil {
  3665  			return 0, err
  3666  		}
  3667  		i -= size
  3668  		i = encodeVarint(dAtA, i, uint64(size))
  3669  		i--
  3670  		dAtA[i] = 0x12
  3671  	}
  3672  	if m.EffectiveCallerId != nil {
  3673  		size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i])
  3674  		if err != nil {
  3675  			return 0, err
  3676  		}
  3677  		i -= size
  3678  		i = encodeVarint(dAtA, i, uint64(size))
  3679  		i--
  3680  		dAtA[i] = 0xa
  3681  	}
  3682  	return len(dAtA) - i, nil
  3683  }
  3684  
  3685  func (m *ReleaseResponse) MarshalVT() (dAtA []byte, err error) {
  3686  	if m == nil {
  3687  		return nil, nil
  3688  	}
  3689  	size := m.SizeVT()
  3690  	dAtA = make([]byte, size)
  3691  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3692  	if err != nil {
  3693  		return nil, err
  3694  	}
  3695  	return dAtA[:n], nil
  3696  }
  3697  
  3698  func (m *ReleaseResponse) MarshalToVT(dAtA []byte) (int, error) {
  3699  	size := m.SizeVT()
  3700  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3701  }
  3702  
  3703  func (m *ReleaseResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3704  	if m == nil {
  3705  		return 0, nil
  3706  	}
  3707  	i := len(dAtA)
  3708  	_ = i
  3709  	var l int
  3710  	_ = l
  3711  	if m.unknownFields != nil {
  3712  		i -= len(m.unknownFields)
  3713  		copy(dAtA[i:], m.unknownFields)
  3714  	}
  3715  	return len(dAtA) - i, nil
  3716  }
  3717  
  3718  func (m *StreamHealthRequest) MarshalVT() (dAtA []byte, err error) {
  3719  	if m == nil {
  3720  		return nil, nil
  3721  	}
  3722  	size := m.SizeVT()
  3723  	dAtA = make([]byte, size)
  3724  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3725  	if err != nil {
  3726  		return nil, err
  3727  	}
  3728  	return dAtA[:n], nil
  3729  }
  3730  
  3731  func (m *StreamHealthRequest) MarshalToVT(dAtA []byte) (int, error) {
  3732  	size := m.SizeVT()
  3733  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3734  }
  3735  
  3736  func (m *StreamHealthRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3737  	if m == nil {
  3738  		return 0, nil
  3739  	}
  3740  	i := len(dAtA)
  3741  	_ = i
  3742  	var l int
  3743  	_ = l
  3744  	if m.unknownFields != nil {
  3745  		i -= len(m.unknownFields)
  3746  		copy(dAtA[i:], m.unknownFields)
  3747  	}
  3748  	return len(dAtA) - i, nil
  3749  }
  3750  
  3751  func (m *RealtimeStats) MarshalVT() (dAtA []byte, err error) {
  3752  	if m == nil {
  3753  		return nil, nil
  3754  	}
  3755  	size := m.SizeVT()
  3756  	dAtA = make([]byte, size)
  3757  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3758  	if err != nil {
  3759  		return nil, err
  3760  	}
  3761  	return dAtA[:n], nil
  3762  }
  3763  
  3764  func (m *RealtimeStats) MarshalToVT(dAtA []byte) (int, error) {
  3765  	size := m.SizeVT()
  3766  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3767  }
  3768  
  3769  func (m *RealtimeStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3770  	if m == nil {
  3771  		return 0, nil
  3772  	}
  3773  	i := len(dAtA)
  3774  	_ = i
  3775  	var l int
  3776  	_ = l
  3777  	if m.unknownFields != nil {
  3778  		i -= len(m.unknownFields)
  3779  		copy(dAtA[i:], m.unknownFields)
  3780  	}
  3781  	if len(m.TableSchemaChanged) > 0 {
  3782  		for iNdEx := len(m.TableSchemaChanged) - 1; iNdEx >= 0; iNdEx-- {
  3783  			i -= len(m.TableSchemaChanged[iNdEx])
  3784  			copy(dAtA[i:], m.TableSchemaChanged[iNdEx])
  3785  			i = encodeVarint(dAtA, i, uint64(len(m.TableSchemaChanged[iNdEx])))
  3786  			i--
  3787  			dAtA[i] = 0x3a
  3788  		}
  3789  	}
  3790  	if m.Qps != 0 {
  3791  		i -= 8
  3792  		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Qps))))
  3793  		i--
  3794  		dAtA[i] = 0x31
  3795  	}
  3796  	if m.CpuUsage != 0 {
  3797  		i -= 8
  3798  		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CpuUsage))))
  3799  		i--
  3800  		dAtA[i] = 0x29
  3801  	}
  3802  	if m.FilteredReplicationLagSeconds != 0 {
  3803  		i = encodeVarint(dAtA, i, uint64(m.FilteredReplicationLagSeconds))
  3804  		i--
  3805  		dAtA[i] = 0x20
  3806  	}
  3807  	if m.BinlogPlayersCount != 0 {
  3808  		i = encodeVarint(dAtA, i, uint64(m.BinlogPlayersCount))
  3809  		i--
  3810  		dAtA[i] = 0x18
  3811  	}
  3812  	if m.ReplicationLagSeconds != 0 {
  3813  		i = encodeVarint(dAtA, i, uint64(m.ReplicationLagSeconds))
  3814  		i--
  3815  		dAtA[i] = 0x10
  3816  	}
  3817  	if len(m.HealthError) > 0 {
  3818  		i -= len(m.HealthError)
  3819  		copy(dAtA[i:], m.HealthError)
  3820  		i = encodeVarint(dAtA, i, uint64(len(m.HealthError)))
  3821  		i--
  3822  		dAtA[i] = 0xa
  3823  	}
  3824  	return len(dAtA) - i, nil
  3825  }
  3826  
  3827  func (m *AggregateStats) MarshalVT() (dAtA []byte, err error) {
  3828  	if m == nil {
  3829  		return nil, nil
  3830  	}
  3831  	size := m.SizeVT()
  3832  	dAtA = make([]byte, size)
  3833  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3834  	if err != nil {
  3835  		return nil, err
  3836  	}
  3837  	return dAtA[:n], nil
  3838  }
  3839  
  3840  func (m *AggregateStats) MarshalToVT(dAtA []byte) (int, error) {
  3841  	size := m.SizeVT()
  3842  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3843  }
  3844  
  3845  func (m *AggregateStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3846  	if m == nil {
  3847  		return 0, nil
  3848  	}
  3849  	i := len(dAtA)
  3850  	_ = i
  3851  	var l int
  3852  	_ = l
  3853  	if m.unknownFields != nil {
  3854  		i -= len(m.unknownFields)
  3855  		copy(dAtA[i:], m.unknownFields)
  3856  	}
  3857  	if m.ReplicationLagSecondsMax != 0 {
  3858  		i = encodeVarint(dAtA, i, uint64(m.ReplicationLagSecondsMax))
  3859  		i--
  3860  		dAtA[i] = 0x20
  3861  	}
  3862  	if m.ReplicationLagSecondsMin != 0 {
  3863  		i = encodeVarint(dAtA, i, uint64(m.ReplicationLagSecondsMin))
  3864  		i--
  3865  		dAtA[i] = 0x18
  3866  	}
  3867  	if m.UnhealthyTabletCount != 0 {
  3868  		i = encodeVarint(dAtA, i, uint64(m.UnhealthyTabletCount))
  3869  		i--
  3870  		dAtA[i] = 0x10
  3871  	}
  3872  	if m.HealthyTabletCount != 0 {
  3873  		i = encodeVarint(dAtA, i, uint64(m.HealthyTabletCount))
  3874  		i--
  3875  		dAtA[i] = 0x8
  3876  	}
  3877  	return len(dAtA) - i, nil
  3878  }
  3879  
  3880  func (m *StreamHealthResponse) MarshalVT() (dAtA []byte, err error) {
  3881  	if m == nil {
  3882  		return nil, nil
  3883  	}
  3884  	size := m.SizeVT()
  3885  	dAtA = make([]byte, size)
  3886  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3887  	if err != nil {
  3888  		return nil, err
  3889  	}
  3890  	return dAtA[:n], nil
  3891  }
  3892  
  3893  func (m *StreamHealthResponse) MarshalToVT(dAtA []byte) (int, error) {
  3894  	size := m.SizeVT()
  3895  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3896  }
  3897  
  3898  func (m *StreamHealthResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3899  	if m == nil {
  3900  		return 0, nil
  3901  	}
  3902  	i := len(dAtA)
  3903  	_ = i
  3904  	var l int
  3905  	_ = l
  3906  	if m.unknownFields != nil {
  3907  		i -= len(m.unknownFields)
  3908  		copy(dAtA[i:], m.unknownFields)
  3909  	}
  3910  	if m.TabletAlias != nil {
  3911  		size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i])
  3912  		if err != nil {
  3913  			return 0, err
  3914  		}
  3915  		i -= size
  3916  		i = encodeVarint(dAtA, i, uint64(size))
  3917  		i--
  3918  		dAtA[i] = 0x2a
  3919  	}
  3920  	if m.RealtimeStats != nil {
  3921  		size, err := m.RealtimeStats.MarshalToSizedBufferVT(dAtA[:i])
  3922  		if err != nil {
  3923  			return 0, err
  3924  		}
  3925  		i -= size
  3926  		i = encodeVarint(dAtA, i, uint64(size))
  3927  		i--
  3928  		dAtA[i] = 0x22
  3929  	}
  3930  	if m.TabletExternallyReparentedTimestamp != 0 {
  3931  		i = encodeVarint(dAtA, i, uint64(m.TabletExternallyReparentedTimestamp))
  3932  		i--
  3933  		dAtA[i] = 0x18
  3934  	}
  3935  	if m.Serving {
  3936  		i--
  3937  		if m.Serving {
  3938  			dAtA[i] = 1
  3939  		} else {
  3940  			dAtA[i] = 0
  3941  		}
  3942  		i--
  3943  		dAtA[i] = 0x10
  3944  	}
  3945  	if m.Target != nil {
  3946  		size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i])
  3947  		if err != nil {
  3948  			return 0, err
  3949  		}
  3950  		i -= size
  3951  		i = encodeVarint(dAtA, i, uint64(size))
  3952  		i--
  3953  		dAtA[i] = 0xa
  3954  	}
  3955  	return len(dAtA) - i, nil
  3956  }
  3957  
  3958  func (m *TransactionMetadata) MarshalVT() (dAtA []byte, err error) {
  3959  	if m == nil {
  3960  		return nil, nil
  3961  	}
  3962  	size := m.SizeVT()
  3963  	dAtA = make([]byte, size)
  3964  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3965  	if err != nil {
  3966  		return nil, err
  3967  	}
  3968  	return dAtA[:n], nil
  3969  }
  3970  
  3971  func (m *TransactionMetadata) MarshalToVT(dAtA []byte) (int, error) {
  3972  	size := m.SizeVT()
  3973  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3974  }
  3975  
  3976  func (m *TransactionMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3977  	if m == nil {
  3978  		return 0, nil
  3979  	}
  3980  	i := len(dAtA)
  3981  	_ = i
  3982  	var l int
  3983  	_ = l
  3984  	if m.unknownFields != nil {
  3985  		i -= len(m.unknownFields)
  3986  		copy(dAtA[i:], m.unknownFields)
  3987  	}
  3988  	if len(m.Participants) > 0 {
  3989  		for iNdEx := len(m.Participants) - 1; iNdEx >= 0; iNdEx-- {
  3990  			size, err := m.Participants[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  3991  			if err != nil {
  3992  				return 0, err
  3993  			}
  3994  			i -= size
  3995  			i = encodeVarint(dAtA, i, uint64(size))
  3996  			i--
  3997  			dAtA[i] = 0x22
  3998  		}
  3999  	}
  4000  	if m.TimeCreated != 0 {
  4001  		i = encodeVarint(dAtA, i, uint64(m.TimeCreated))
  4002  		i--
  4003  		dAtA[i] = 0x18
  4004  	}
  4005  	if m.State != 0 {
  4006  		i = encodeVarint(dAtA, i, uint64(m.State))
  4007  		i--
  4008  		dAtA[i] = 0x10
  4009  	}
  4010  	if len(m.Dtid) > 0 {
  4011  		i -= len(m.Dtid)
  4012  		copy(dAtA[i:], m.Dtid)
  4013  		i = encodeVarint(dAtA, i, uint64(len(m.Dtid)))
  4014  		i--
  4015  		dAtA[i] = 0xa
  4016  	}
  4017  	return len(dAtA) - i, nil
  4018  }
  4019  
  4020  func encodeVarint(dAtA []byte, offset int, v uint64) int {
  4021  	offset -= sov(v)
  4022  	base := offset
  4023  	for v >= 1<<7 {
  4024  		dAtA[offset] = uint8(v&0x7f | 0x80)
  4025  		v >>= 7
  4026  		offset++
  4027  	}
  4028  	dAtA[offset] = uint8(v)
  4029  	return base
  4030  }
  4031  
  4032  var vtprotoPool_Row = sync.Pool{
  4033  	New: func() interface{} {
  4034  		return &Row{}
  4035  	},
  4036  }
  4037  
  4038  func (m *Row) ResetVT() {
  4039  	f0 := m.Lengths[:0]
  4040  	f1 := m.Values[:0]
  4041  	m.Reset()
  4042  	m.Lengths = f0
  4043  	m.Values = f1
  4044  }
  4045  func (m *Row) ReturnToVTPool() {
  4046  	if m != nil {
  4047  		m.ResetVT()
  4048  		vtprotoPool_Row.Put(m)
  4049  	}
  4050  }
  4051  func RowFromVTPool() *Row {
  4052  	return vtprotoPool_Row.Get().(*Row)
  4053  }
  4054  func (m *Target) SizeVT() (n int) {
  4055  	if m == nil {
  4056  		return 0
  4057  	}
  4058  	var l int
  4059  	_ = l
  4060  	l = len(m.Keyspace)
  4061  	if l > 0 {
  4062  		n += 1 + l + sov(uint64(l))
  4063  	}
  4064  	l = len(m.Shard)
  4065  	if l > 0 {
  4066  		n += 1 + l + sov(uint64(l))
  4067  	}
  4068  	if m.TabletType != 0 {
  4069  		n += 1 + sov(uint64(m.TabletType))
  4070  	}
  4071  	l = len(m.Cell)
  4072  	if l > 0 {
  4073  		n += 1 + l + sov(uint64(l))
  4074  	}
  4075  	if m.unknownFields != nil {
  4076  		n += len(m.unknownFields)
  4077  	}
  4078  	return n
  4079  }
  4080  
  4081  func (m *VTGateCallerID) SizeVT() (n int) {
  4082  	if m == nil {
  4083  		return 0
  4084  	}
  4085  	var l int
  4086  	_ = l
  4087  	l = len(m.Username)
  4088  	if l > 0 {
  4089  		n += 1 + l + sov(uint64(l))
  4090  	}
  4091  	if len(m.Groups) > 0 {
  4092  		for _, s := range m.Groups {
  4093  			l = len(s)
  4094  			n += 1 + l + sov(uint64(l))
  4095  		}
  4096  	}
  4097  	if m.unknownFields != nil {
  4098  		n += len(m.unknownFields)
  4099  	}
  4100  	return n
  4101  }
  4102  
  4103  func (m *EventToken) SizeVT() (n int) {
  4104  	if m == nil {
  4105  		return 0
  4106  	}
  4107  	var l int
  4108  	_ = l
  4109  	if m.Timestamp != 0 {
  4110  		n += 1 + sov(uint64(m.Timestamp))
  4111  	}
  4112  	l = len(m.Shard)
  4113  	if l > 0 {
  4114  		n += 1 + l + sov(uint64(l))
  4115  	}
  4116  	l = len(m.Position)
  4117  	if l > 0 {
  4118  		n += 1 + l + sov(uint64(l))
  4119  	}
  4120  	if m.unknownFields != nil {
  4121  		n += len(m.unknownFields)
  4122  	}
  4123  	return n
  4124  }
  4125  
  4126  func (m *Value) SizeVT() (n int) {
  4127  	if m == nil {
  4128  		return 0
  4129  	}
  4130  	var l int
  4131  	_ = l
  4132  	if m.Type != 0 {
  4133  		n += 1 + sov(uint64(m.Type))
  4134  	}
  4135  	l = len(m.Value)
  4136  	if l > 0 {
  4137  		n += 1 + l + sov(uint64(l))
  4138  	}
  4139  	if m.unknownFields != nil {
  4140  		n += len(m.unknownFields)
  4141  	}
  4142  	return n
  4143  }
  4144  
  4145  func (m *BindVariable) SizeVT() (n int) {
  4146  	if m == nil {
  4147  		return 0
  4148  	}
  4149  	var l int
  4150  	_ = l
  4151  	if m.Type != 0 {
  4152  		n += 1 + sov(uint64(m.Type))
  4153  	}
  4154  	l = len(m.Value)
  4155  	if l > 0 {
  4156  		n += 1 + l + sov(uint64(l))
  4157  	}
  4158  	if len(m.Values) > 0 {
  4159  		for _, e := range m.Values {
  4160  			l = e.SizeVT()
  4161  			n += 1 + l + sov(uint64(l))
  4162  		}
  4163  	}
  4164  	if m.unknownFields != nil {
  4165  		n += len(m.unknownFields)
  4166  	}
  4167  	return n
  4168  }
  4169  
  4170  func (m *BoundQuery) SizeVT() (n int) {
  4171  	if m == nil {
  4172  		return 0
  4173  	}
  4174  	var l int
  4175  	_ = l
  4176  	l = len(m.Sql)
  4177  	if l > 0 {
  4178  		n += 1 + l + sov(uint64(l))
  4179  	}
  4180  	if len(m.BindVariables) > 0 {
  4181  		for k, v := range m.BindVariables {
  4182  			_ = k
  4183  			_ = v
  4184  			l = 0
  4185  			if v != nil {
  4186  				l = v.SizeVT()
  4187  			}
  4188  			l += 1 + sov(uint64(l))
  4189  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l
  4190  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  4191  		}
  4192  	}
  4193  	if m.unknownFields != nil {
  4194  		n += len(m.unknownFields)
  4195  	}
  4196  	return n
  4197  }
  4198  
  4199  func (m *ExecuteOptions) SizeVT() (n int) {
  4200  	if m == nil {
  4201  		return 0
  4202  	}
  4203  	var l int
  4204  	_ = l
  4205  	if m.IncludedFields != 0 {
  4206  		n += 1 + sov(uint64(m.IncludedFields))
  4207  	}
  4208  	if m.ClientFoundRows {
  4209  		n += 2
  4210  	}
  4211  	if m.Workload != 0 {
  4212  		n += 1 + sov(uint64(m.Workload))
  4213  	}
  4214  	if m.SqlSelectLimit != 0 {
  4215  		n += 1 + sov(uint64(m.SqlSelectLimit))
  4216  	}
  4217  	if m.TransactionIsolation != 0 {
  4218  		n += 1 + sov(uint64(m.TransactionIsolation))
  4219  	}
  4220  	if m.SkipQueryPlanCache {
  4221  		n += 2
  4222  	}
  4223  	if m.PlannerVersion != 0 {
  4224  		n += 1 + sov(uint64(m.PlannerVersion))
  4225  	}
  4226  	if m.HasCreatedTempTables {
  4227  		n += 2
  4228  	}
  4229  	if m.unknownFields != nil {
  4230  		n += len(m.unknownFields)
  4231  	}
  4232  	return n
  4233  }
  4234  
  4235  func (m *Field) SizeVT() (n int) {
  4236  	if m == nil {
  4237  		return 0
  4238  	}
  4239  	var l int
  4240  	_ = l
  4241  	l = len(m.Name)
  4242  	if l > 0 {
  4243  		n += 1 + l + sov(uint64(l))
  4244  	}
  4245  	if m.Type != 0 {
  4246  		n += 1 + sov(uint64(m.Type))
  4247  	}
  4248  	l = len(m.Table)
  4249  	if l > 0 {
  4250  		n += 1 + l + sov(uint64(l))
  4251  	}
  4252  	l = len(m.OrgTable)
  4253  	if l > 0 {
  4254  		n += 1 + l + sov(uint64(l))
  4255  	}
  4256  	l = len(m.Database)
  4257  	if l > 0 {
  4258  		n += 1 + l + sov(uint64(l))
  4259  	}
  4260  	l = len(m.OrgName)
  4261  	if l > 0 {
  4262  		n += 1 + l + sov(uint64(l))
  4263  	}
  4264  	if m.ColumnLength != 0 {
  4265  		n += 1 + sov(uint64(m.ColumnLength))
  4266  	}
  4267  	if m.Charset != 0 {
  4268  		n += 1 + sov(uint64(m.Charset))
  4269  	}
  4270  	if m.Decimals != 0 {
  4271  		n += 1 + sov(uint64(m.Decimals))
  4272  	}
  4273  	if m.Flags != 0 {
  4274  		n += 1 + sov(uint64(m.Flags))
  4275  	}
  4276  	l = len(m.ColumnType)
  4277  	if l > 0 {
  4278  		n += 1 + l + sov(uint64(l))
  4279  	}
  4280  	if m.unknownFields != nil {
  4281  		n += len(m.unknownFields)
  4282  	}
  4283  	return n
  4284  }
  4285  
  4286  func (m *Row) SizeVT() (n int) {
  4287  	if m == nil {
  4288  		return 0
  4289  	}
  4290  	var l int
  4291  	_ = l
  4292  	if len(m.Lengths) > 0 {
  4293  		l = 0
  4294  		for _, e := range m.Lengths {
  4295  			l += soz(uint64(e))
  4296  		}
  4297  		n += 1 + sov(uint64(l)) + l
  4298  	}
  4299  	l = len(m.Values)
  4300  	if l > 0 {
  4301  		n += 1 + l + sov(uint64(l))
  4302  	}
  4303  	if m.unknownFields != nil {
  4304  		n += len(m.unknownFields)
  4305  	}
  4306  	return n
  4307  }
  4308  
  4309  func (m *QueryResult) SizeVT() (n int) {
  4310  	if m == nil {
  4311  		return 0
  4312  	}
  4313  	var l int
  4314  	_ = l
  4315  	if len(m.Fields) > 0 {
  4316  		for _, e := range m.Fields {
  4317  			l = e.SizeVT()
  4318  			n += 1 + l + sov(uint64(l))
  4319  		}
  4320  	}
  4321  	if m.RowsAffected != 0 {
  4322  		n += 1 + sov(uint64(m.RowsAffected))
  4323  	}
  4324  	if m.InsertId != 0 {
  4325  		n += 1 + sov(uint64(m.InsertId))
  4326  	}
  4327  	if len(m.Rows) > 0 {
  4328  		for _, e := range m.Rows {
  4329  			l = e.SizeVT()
  4330  			n += 1 + l + sov(uint64(l))
  4331  		}
  4332  	}
  4333  	if m.unknownFields != nil {
  4334  		n += len(m.unknownFields)
  4335  	}
  4336  	return n
  4337  }
  4338  
  4339  func (m *QueryWarning) SizeVT() (n int) {
  4340  	if m == nil {
  4341  		return 0
  4342  	}
  4343  	var l int
  4344  	_ = l
  4345  	if m.Code != 0 {
  4346  		n += 1 + sov(uint64(m.Code))
  4347  	}
  4348  	l = len(m.Message)
  4349  	if l > 0 {
  4350  		n += 1 + l + sov(uint64(l))
  4351  	}
  4352  	if m.unknownFields != nil {
  4353  		n += len(m.unknownFields)
  4354  	}
  4355  	return n
  4356  }
  4357  
  4358  func (m *StreamEvent_Statement) SizeVT() (n int) {
  4359  	if m == nil {
  4360  		return 0
  4361  	}
  4362  	var l int
  4363  	_ = l
  4364  	if m.Category != 0 {
  4365  		n += 1 + sov(uint64(m.Category))
  4366  	}
  4367  	l = len(m.TableName)
  4368  	if l > 0 {
  4369  		n += 1 + l + sov(uint64(l))
  4370  	}
  4371  	if len(m.PrimaryKeyFields) > 0 {
  4372  		for _, e := range m.PrimaryKeyFields {
  4373  			l = e.SizeVT()
  4374  			n += 1 + l + sov(uint64(l))
  4375  		}
  4376  	}
  4377  	if len(m.PrimaryKeyValues) > 0 {
  4378  		for _, e := range m.PrimaryKeyValues {
  4379  			l = e.SizeVT()
  4380  			n += 1 + l + sov(uint64(l))
  4381  		}
  4382  	}
  4383  	l = len(m.Sql)
  4384  	if l > 0 {
  4385  		n += 1 + l + sov(uint64(l))
  4386  	}
  4387  	if m.unknownFields != nil {
  4388  		n += len(m.unknownFields)
  4389  	}
  4390  	return n
  4391  }
  4392  
  4393  func (m *StreamEvent) SizeVT() (n int) {
  4394  	if m == nil {
  4395  		return 0
  4396  	}
  4397  	var l int
  4398  	_ = l
  4399  	if len(m.Statements) > 0 {
  4400  		for _, e := range m.Statements {
  4401  			l = e.SizeVT()
  4402  			n += 1 + l + sov(uint64(l))
  4403  		}
  4404  	}
  4405  	if m.EventToken != nil {
  4406  		l = m.EventToken.SizeVT()
  4407  		n += 1 + l + sov(uint64(l))
  4408  	}
  4409  	if m.unknownFields != nil {
  4410  		n += len(m.unknownFields)
  4411  	}
  4412  	return n
  4413  }
  4414  
  4415  func (m *ExecuteRequest) SizeVT() (n int) {
  4416  	if m == nil {
  4417  		return 0
  4418  	}
  4419  	var l int
  4420  	_ = l
  4421  	if m.EffectiveCallerId != nil {
  4422  		l = m.EffectiveCallerId.SizeVT()
  4423  		n += 1 + l + sov(uint64(l))
  4424  	}
  4425  	if m.ImmediateCallerId != nil {
  4426  		l = m.ImmediateCallerId.SizeVT()
  4427  		n += 1 + l + sov(uint64(l))
  4428  	}
  4429  	if m.Target != nil {
  4430  		l = m.Target.SizeVT()
  4431  		n += 1 + l + sov(uint64(l))
  4432  	}
  4433  	if m.Query != nil {
  4434  		l = m.Query.SizeVT()
  4435  		n += 1 + l + sov(uint64(l))
  4436  	}
  4437  	if m.TransactionId != 0 {
  4438  		n += 1 + sov(uint64(m.TransactionId))
  4439  	}
  4440  	if m.Options != nil {
  4441  		l = m.Options.SizeVT()
  4442  		n += 1 + l + sov(uint64(l))
  4443  	}
  4444  	if m.ReservedId != 0 {
  4445  		n += 1 + sov(uint64(m.ReservedId))
  4446  	}
  4447  	if m.unknownFields != nil {
  4448  		n += len(m.unknownFields)
  4449  	}
  4450  	return n
  4451  }
  4452  
  4453  func (m *ExecuteResponse) SizeVT() (n int) {
  4454  	if m == nil {
  4455  		return 0
  4456  	}
  4457  	var l int
  4458  	_ = l
  4459  	if m.Result != nil {
  4460  		l = m.Result.SizeVT()
  4461  		n += 1 + l + sov(uint64(l))
  4462  	}
  4463  	if m.unknownFields != nil {
  4464  		n += len(m.unknownFields)
  4465  	}
  4466  	return n
  4467  }
  4468  
  4469  func (m *ResultWithError) SizeVT() (n int) {
  4470  	if m == nil {
  4471  		return 0
  4472  	}
  4473  	var l int
  4474  	_ = l
  4475  	if m.Error != nil {
  4476  		l = m.Error.SizeVT()
  4477  		n += 1 + l + sov(uint64(l))
  4478  	}
  4479  	if m.Result != nil {
  4480  		l = m.Result.SizeVT()
  4481  		n += 1 + l + sov(uint64(l))
  4482  	}
  4483  	if m.unknownFields != nil {
  4484  		n += len(m.unknownFields)
  4485  	}
  4486  	return n
  4487  }
  4488  
  4489  func (m *StreamExecuteRequest) SizeVT() (n int) {
  4490  	if m == nil {
  4491  		return 0
  4492  	}
  4493  	var l int
  4494  	_ = l
  4495  	if m.EffectiveCallerId != nil {
  4496  		l = m.EffectiveCallerId.SizeVT()
  4497  		n += 1 + l + sov(uint64(l))
  4498  	}
  4499  	if m.ImmediateCallerId != nil {
  4500  		l = m.ImmediateCallerId.SizeVT()
  4501  		n += 1 + l + sov(uint64(l))
  4502  	}
  4503  	if m.Target != nil {
  4504  		l = m.Target.SizeVT()
  4505  		n += 1 + l + sov(uint64(l))
  4506  	}
  4507  	if m.Query != nil {
  4508  		l = m.Query.SizeVT()
  4509  		n += 1 + l + sov(uint64(l))
  4510  	}
  4511  	if m.Options != nil {
  4512  		l = m.Options.SizeVT()
  4513  		n += 1 + l + sov(uint64(l))
  4514  	}
  4515  	if m.TransactionId != 0 {
  4516  		n += 1 + sov(uint64(m.TransactionId))
  4517  	}
  4518  	if m.ReservedId != 0 {
  4519  		n += 1 + sov(uint64(m.ReservedId))
  4520  	}
  4521  	if m.unknownFields != nil {
  4522  		n += len(m.unknownFields)
  4523  	}
  4524  	return n
  4525  }
  4526  
  4527  func (m *StreamExecuteResponse) SizeVT() (n int) {
  4528  	if m == nil {
  4529  		return 0
  4530  	}
  4531  	var l int
  4532  	_ = l
  4533  	if m.Result != nil {
  4534  		l = m.Result.SizeVT()
  4535  		n += 1 + l + sov(uint64(l))
  4536  	}
  4537  	if m.unknownFields != nil {
  4538  		n += len(m.unknownFields)
  4539  	}
  4540  	return n
  4541  }
  4542  
  4543  func (m *BeginRequest) SizeVT() (n int) {
  4544  	if m == nil {
  4545  		return 0
  4546  	}
  4547  	var l int
  4548  	_ = l
  4549  	if m.EffectiveCallerId != nil {
  4550  		l = m.EffectiveCallerId.SizeVT()
  4551  		n += 1 + l + sov(uint64(l))
  4552  	}
  4553  	if m.ImmediateCallerId != nil {
  4554  		l = m.ImmediateCallerId.SizeVT()
  4555  		n += 1 + l + sov(uint64(l))
  4556  	}
  4557  	if m.Target != nil {
  4558  		l = m.Target.SizeVT()
  4559  		n += 1 + l + sov(uint64(l))
  4560  	}
  4561  	if m.Options != nil {
  4562  		l = m.Options.SizeVT()
  4563  		n += 1 + l + sov(uint64(l))
  4564  	}
  4565  	if m.unknownFields != nil {
  4566  		n += len(m.unknownFields)
  4567  	}
  4568  	return n
  4569  }
  4570  
  4571  func (m *BeginResponse) SizeVT() (n int) {
  4572  	if m == nil {
  4573  		return 0
  4574  	}
  4575  	var l int
  4576  	_ = l
  4577  	if m.TransactionId != 0 {
  4578  		n += 1 + sov(uint64(m.TransactionId))
  4579  	}
  4580  	if m.TabletAlias != nil {
  4581  		l = m.TabletAlias.SizeVT()
  4582  		n += 1 + l + sov(uint64(l))
  4583  	}
  4584  	if m.unknownFields != nil {
  4585  		n += len(m.unknownFields)
  4586  	}
  4587  	return n
  4588  }
  4589  
  4590  func (m *CommitRequest) SizeVT() (n int) {
  4591  	if m == nil {
  4592  		return 0
  4593  	}
  4594  	var l int
  4595  	_ = l
  4596  	if m.EffectiveCallerId != nil {
  4597  		l = m.EffectiveCallerId.SizeVT()
  4598  		n += 1 + l + sov(uint64(l))
  4599  	}
  4600  	if m.ImmediateCallerId != nil {
  4601  		l = m.ImmediateCallerId.SizeVT()
  4602  		n += 1 + l + sov(uint64(l))
  4603  	}
  4604  	if m.Target != nil {
  4605  		l = m.Target.SizeVT()
  4606  		n += 1 + l + sov(uint64(l))
  4607  	}
  4608  	if m.TransactionId != 0 {
  4609  		n += 1 + sov(uint64(m.TransactionId))
  4610  	}
  4611  	if m.unknownFields != nil {
  4612  		n += len(m.unknownFields)
  4613  	}
  4614  	return n
  4615  }
  4616  
  4617  func (m *CommitResponse) SizeVT() (n int) {
  4618  	if m == nil {
  4619  		return 0
  4620  	}
  4621  	var l int
  4622  	_ = l
  4623  	if m.ReservedId != 0 {
  4624  		n += 1 + sov(uint64(m.ReservedId))
  4625  	}
  4626  	if m.unknownFields != nil {
  4627  		n += len(m.unknownFields)
  4628  	}
  4629  	return n
  4630  }
  4631  
  4632  func (m *RollbackRequest) SizeVT() (n int) {
  4633  	if m == nil {
  4634  		return 0
  4635  	}
  4636  	var l int
  4637  	_ = l
  4638  	if m.EffectiveCallerId != nil {
  4639  		l = m.EffectiveCallerId.SizeVT()
  4640  		n += 1 + l + sov(uint64(l))
  4641  	}
  4642  	if m.ImmediateCallerId != nil {
  4643  		l = m.ImmediateCallerId.SizeVT()
  4644  		n += 1 + l + sov(uint64(l))
  4645  	}
  4646  	if m.Target != nil {
  4647  		l = m.Target.SizeVT()
  4648  		n += 1 + l + sov(uint64(l))
  4649  	}
  4650  	if m.TransactionId != 0 {
  4651  		n += 1 + sov(uint64(m.TransactionId))
  4652  	}
  4653  	if m.unknownFields != nil {
  4654  		n += len(m.unknownFields)
  4655  	}
  4656  	return n
  4657  }
  4658  
  4659  func (m *RollbackResponse) SizeVT() (n int) {
  4660  	if m == nil {
  4661  		return 0
  4662  	}
  4663  	var l int
  4664  	_ = l
  4665  	if m.ReservedId != 0 {
  4666  		n += 1 + sov(uint64(m.ReservedId))
  4667  	}
  4668  	if m.unknownFields != nil {
  4669  		n += len(m.unknownFields)
  4670  	}
  4671  	return n
  4672  }
  4673  
  4674  func (m *PrepareRequest) SizeVT() (n int) {
  4675  	if m == nil {
  4676  		return 0
  4677  	}
  4678  	var l int
  4679  	_ = l
  4680  	if m.EffectiveCallerId != nil {
  4681  		l = m.EffectiveCallerId.SizeVT()
  4682  		n += 1 + l + sov(uint64(l))
  4683  	}
  4684  	if m.ImmediateCallerId != nil {
  4685  		l = m.ImmediateCallerId.SizeVT()
  4686  		n += 1 + l + sov(uint64(l))
  4687  	}
  4688  	if m.Target != nil {
  4689  		l = m.Target.SizeVT()
  4690  		n += 1 + l + sov(uint64(l))
  4691  	}
  4692  	if m.TransactionId != 0 {
  4693  		n += 1 + sov(uint64(m.TransactionId))
  4694  	}
  4695  	l = len(m.Dtid)
  4696  	if l > 0 {
  4697  		n += 1 + l + sov(uint64(l))
  4698  	}
  4699  	if m.unknownFields != nil {
  4700  		n += len(m.unknownFields)
  4701  	}
  4702  	return n
  4703  }
  4704  
  4705  func (m *PrepareResponse) SizeVT() (n int) {
  4706  	if m == nil {
  4707  		return 0
  4708  	}
  4709  	var l int
  4710  	_ = l
  4711  	if m.unknownFields != nil {
  4712  		n += len(m.unknownFields)
  4713  	}
  4714  	return n
  4715  }
  4716  
  4717  func (m *CommitPreparedRequest) SizeVT() (n int) {
  4718  	if m == nil {
  4719  		return 0
  4720  	}
  4721  	var l int
  4722  	_ = l
  4723  	if m.EffectiveCallerId != nil {
  4724  		l = m.EffectiveCallerId.SizeVT()
  4725  		n += 1 + l + sov(uint64(l))
  4726  	}
  4727  	if m.ImmediateCallerId != nil {
  4728  		l = m.ImmediateCallerId.SizeVT()
  4729  		n += 1 + l + sov(uint64(l))
  4730  	}
  4731  	if m.Target != nil {
  4732  		l = m.Target.SizeVT()
  4733  		n += 1 + l + sov(uint64(l))
  4734  	}
  4735  	l = len(m.Dtid)
  4736  	if l > 0 {
  4737  		n += 1 + l + sov(uint64(l))
  4738  	}
  4739  	if m.unknownFields != nil {
  4740  		n += len(m.unknownFields)
  4741  	}
  4742  	return n
  4743  }
  4744  
  4745  func (m *CommitPreparedResponse) SizeVT() (n int) {
  4746  	if m == nil {
  4747  		return 0
  4748  	}
  4749  	var l int
  4750  	_ = l
  4751  	if m.unknownFields != nil {
  4752  		n += len(m.unknownFields)
  4753  	}
  4754  	return n
  4755  }
  4756  
  4757  func (m *RollbackPreparedRequest) SizeVT() (n int) {
  4758  	if m == nil {
  4759  		return 0
  4760  	}
  4761  	var l int
  4762  	_ = l
  4763  	if m.EffectiveCallerId != nil {
  4764  		l = m.EffectiveCallerId.SizeVT()
  4765  		n += 1 + l + sov(uint64(l))
  4766  	}
  4767  	if m.ImmediateCallerId != nil {
  4768  		l = m.ImmediateCallerId.SizeVT()
  4769  		n += 1 + l + sov(uint64(l))
  4770  	}
  4771  	if m.Target != nil {
  4772  		l = m.Target.SizeVT()
  4773  		n += 1 + l + sov(uint64(l))
  4774  	}
  4775  	if m.TransactionId != 0 {
  4776  		n += 1 + sov(uint64(m.TransactionId))
  4777  	}
  4778  	l = len(m.Dtid)
  4779  	if l > 0 {
  4780  		n += 1 + l + sov(uint64(l))
  4781  	}
  4782  	if m.unknownFields != nil {
  4783  		n += len(m.unknownFields)
  4784  	}
  4785  	return n
  4786  }
  4787  
  4788  func (m *RollbackPreparedResponse) SizeVT() (n int) {
  4789  	if m == nil {
  4790  		return 0
  4791  	}
  4792  	var l int
  4793  	_ = l
  4794  	if m.unknownFields != nil {
  4795  		n += len(m.unknownFields)
  4796  	}
  4797  	return n
  4798  }
  4799  
  4800  func (m *CreateTransactionRequest) SizeVT() (n int) {
  4801  	if m == nil {
  4802  		return 0
  4803  	}
  4804  	var l int
  4805  	_ = l
  4806  	if m.EffectiveCallerId != nil {
  4807  		l = m.EffectiveCallerId.SizeVT()
  4808  		n += 1 + l + sov(uint64(l))
  4809  	}
  4810  	if m.ImmediateCallerId != nil {
  4811  		l = m.ImmediateCallerId.SizeVT()
  4812  		n += 1 + l + sov(uint64(l))
  4813  	}
  4814  	if m.Target != nil {
  4815  		l = m.Target.SizeVT()
  4816  		n += 1 + l + sov(uint64(l))
  4817  	}
  4818  	l = len(m.Dtid)
  4819  	if l > 0 {
  4820  		n += 1 + l + sov(uint64(l))
  4821  	}
  4822  	if len(m.Participants) > 0 {
  4823  		for _, e := range m.Participants {
  4824  			l = e.SizeVT()
  4825  			n += 1 + l + sov(uint64(l))
  4826  		}
  4827  	}
  4828  	if m.unknownFields != nil {
  4829  		n += len(m.unknownFields)
  4830  	}
  4831  	return n
  4832  }
  4833  
  4834  func (m *CreateTransactionResponse) SizeVT() (n int) {
  4835  	if m == nil {
  4836  		return 0
  4837  	}
  4838  	var l int
  4839  	_ = l
  4840  	if m.unknownFields != nil {
  4841  		n += len(m.unknownFields)
  4842  	}
  4843  	return n
  4844  }
  4845  
  4846  func (m *StartCommitRequest) SizeVT() (n int) {
  4847  	if m == nil {
  4848  		return 0
  4849  	}
  4850  	var l int
  4851  	_ = l
  4852  	if m.EffectiveCallerId != nil {
  4853  		l = m.EffectiveCallerId.SizeVT()
  4854  		n += 1 + l + sov(uint64(l))
  4855  	}
  4856  	if m.ImmediateCallerId != nil {
  4857  		l = m.ImmediateCallerId.SizeVT()
  4858  		n += 1 + l + sov(uint64(l))
  4859  	}
  4860  	if m.Target != nil {
  4861  		l = m.Target.SizeVT()
  4862  		n += 1 + l + sov(uint64(l))
  4863  	}
  4864  	if m.TransactionId != 0 {
  4865  		n += 1 + sov(uint64(m.TransactionId))
  4866  	}
  4867  	l = len(m.Dtid)
  4868  	if l > 0 {
  4869  		n += 1 + l + sov(uint64(l))
  4870  	}
  4871  	if m.unknownFields != nil {
  4872  		n += len(m.unknownFields)
  4873  	}
  4874  	return n
  4875  }
  4876  
  4877  func (m *StartCommitResponse) SizeVT() (n int) {
  4878  	if m == nil {
  4879  		return 0
  4880  	}
  4881  	var l int
  4882  	_ = l
  4883  	if m.unknownFields != nil {
  4884  		n += len(m.unknownFields)
  4885  	}
  4886  	return n
  4887  }
  4888  
  4889  func (m *SetRollbackRequest) SizeVT() (n int) {
  4890  	if m == nil {
  4891  		return 0
  4892  	}
  4893  	var l int
  4894  	_ = l
  4895  	if m.EffectiveCallerId != nil {
  4896  		l = m.EffectiveCallerId.SizeVT()
  4897  		n += 1 + l + sov(uint64(l))
  4898  	}
  4899  	if m.ImmediateCallerId != nil {
  4900  		l = m.ImmediateCallerId.SizeVT()
  4901  		n += 1 + l + sov(uint64(l))
  4902  	}
  4903  	if m.Target != nil {
  4904  		l = m.Target.SizeVT()
  4905  		n += 1 + l + sov(uint64(l))
  4906  	}
  4907  	if m.TransactionId != 0 {
  4908  		n += 1 + sov(uint64(m.TransactionId))
  4909  	}
  4910  	l = len(m.Dtid)
  4911  	if l > 0 {
  4912  		n += 1 + l + sov(uint64(l))
  4913  	}
  4914  	if m.unknownFields != nil {
  4915  		n += len(m.unknownFields)
  4916  	}
  4917  	return n
  4918  }
  4919  
  4920  func (m *SetRollbackResponse) SizeVT() (n int) {
  4921  	if m == nil {
  4922  		return 0
  4923  	}
  4924  	var l int
  4925  	_ = l
  4926  	if m.unknownFields != nil {
  4927  		n += len(m.unknownFields)
  4928  	}
  4929  	return n
  4930  }
  4931  
  4932  func (m *ConcludeTransactionRequest) SizeVT() (n int) {
  4933  	if m == nil {
  4934  		return 0
  4935  	}
  4936  	var l int
  4937  	_ = l
  4938  	if m.EffectiveCallerId != nil {
  4939  		l = m.EffectiveCallerId.SizeVT()
  4940  		n += 1 + l + sov(uint64(l))
  4941  	}
  4942  	if m.ImmediateCallerId != nil {
  4943  		l = m.ImmediateCallerId.SizeVT()
  4944  		n += 1 + l + sov(uint64(l))
  4945  	}
  4946  	if m.Target != nil {
  4947  		l = m.Target.SizeVT()
  4948  		n += 1 + l + sov(uint64(l))
  4949  	}
  4950  	l = len(m.Dtid)
  4951  	if l > 0 {
  4952  		n += 1 + l + sov(uint64(l))
  4953  	}
  4954  	if m.unknownFields != nil {
  4955  		n += len(m.unknownFields)
  4956  	}
  4957  	return n
  4958  }
  4959  
  4960  func (m *ConcludeTransactionResponse) SizeVT() (n int) {
  4961  	if m == nil {
  4962  		return 0
  4963  	}
  4964  	var l int
  4965  	_ = l
  4966  	if m.unknownFields != nil {
  4967  		n += len(m.unknownFields)
  4968  	}
  4969  	return n
  4970  }
  4971  
  4972  func (m *ReadTransactionRequest) SizeVT() (n int) {
  4973  	if m == nil {
  4974  		return 0
  4975  	}
  4976  	var l int
  4977  	_ = l
  4978  	if m.EffectiveCallerId != nil {
  4979  		l = m.EffectiveCallerId.SizeVT()
  4980  		n += 1 + l + sov(uint64(l))
  4981  	}
  4982  	if m.ImmediateCallerId != nil {
  4983  		l = m.ImmediateCallerId.SizeVT()
  4984  		n += 1 + l + sov(uint64(l))
  4985  	}
  4986  	if m.Target != nil {
  4987  		l = m.Target.SizeVT()
  4988  		n += 1 + l + sov(uint64(l))
  4989  	}
  4990  	l = len(m.Dtid)
  4991  	if l > 0 {
  4992  		n += 1 + l + sov(uint64(l))
  4993  	}
  4994  	if m.unknownFields != nil {
  4995  		n += len(m.unknownFields)
  4996  	}
  4997  	return n
  4998  }
  4999  
  5000  func (m *ReadTransactionResponse) SizeVT() (n int) {
  5001  	if m == nil {
  5002  		return 0
  5003  	}
  5004  	var l int
  5005  	_ = l
  5006  	if m.Metadata != nil {
  5007  		l = m.Metadata.SizeVT()
  5008  		n += 1 + l + sov(uint64(l))
  5009  	}
  5010  	if m.unknownFields != nil {
  5011  		n += len(m.unknownFields)
  5012  	}
  5013  	return n
  5014  }
  5015  
  5016  func (m *BeginExecuteRequest) SizeVT() (n int) {
  5017  	if m == nil {
  5018  		return 0
  5019  	}
  5020  	var l int
  5021  	_ = l
  5022  	if m.EffectiveCallerId != nil {
  5023  		l = m.EffectiveCallerId.SizeVT()
  5024  		n += 1 + l + sov(uint64(l))
  5025  	}
  5026  	if m.ImmediateCallerId != nil {
  5027  		l = m.ImmediateCallerId.SizeVT()
  5028  		n += 1 + l + sov(uint64(l))
  5029  	}
  5030  	if m.Target != nil {
  5031  		l = m.Target.SizeVT()
  5032  		n += 1 + l + sov(uint64(l))
  5033  	}
  5034  	if m.Query != nil {
  5035  		l = m.Query.SizeVT()
  5036  		n += 1 + l + sov(uint64(l))
  5037  	}
  5038  	if m.Options != nil {
  5039  		l = m.Options.SizeVT()
  5040  		n += 1 + l + sov(uint64(l))
  5041  	}
  5042  	if m.ReservedId != 0 {
  5043  		n += 1 + sov(uint64(m.ReservedId))
  5044  	}
  5045  	if len(m.PreQueries) > 0 {
  5046  		for _, s := range m.PreQueries {
  5047  			l = len(s)
  5048  			n += 1 + l + sov(uint64(l))
  5049  		}
  5050  	}
  5051  	if m.unknownFields != nil {
  5052  		n += len(m.unknownFields)
  5053  	}
  5054  	return n
  5055  }
  5056  
  5057  func (m *BeginExecuteResponse) SizeVT() (n int) {
  5058  	if m == nil {
  5059  		return 0
  5060  	}
  5061  	var l int
  5062  	_ = l
  5063  	if m.Error != nil {
  5064  		l = m.Error.SizeVT()
  5065  		n += 1 + l + sov(uint64(l))
  5066  	}
  5067  	if m.Result != nil {
  5068  		l = m.Result.SizeVT()
  5069  		n += 1 + l + sov(uint64(l))
  5070  	}
  5071  	if m.TransactionId != 0 {
  5072  		n += 1 + sov(uint64(m.TransactionId))
  5073  	}
  5074  	if m.TabletAlias != nil {
  5075  		l = m.TabletAlias.SizeVT()
  5076  		n += 1 + l + sov(uint64(l))
  5077  	}
  5078  	if m.unknownFields != nil {
  5079  		n += len(m.unknownFields)
  5080  	}
  5081  	return n
  5082  }
  5083  
  5084  func (m *BeginStreamExecuteRequest) SizeVT() (n int) {
  5085  	if m == nil {
  5086  		return 0
  5087  	}
  5088  	var l int
  5089  	_ = l
  5090  	if m.EffectiveCallerId != nil {
  5091  		l = m.EffectiveCallerId.SizeVT()
  5092  		n += 1 + l + sov(uint64(l))
  5093  	}
  5094  	if m.ImmediateCallerId != nil {
  5095  		l = m.ImmediateCallerId.SizeVT()
  5096  		n += 1 + l + sov(uint64(l))
  5097  	}
  5098  	if m.Target != nil {
  5099  		l = m.Target.SizeVT()
  5100  		n += 1 + l + sov(uint64(l))
  5101  	}
  5102  	if m.Query != nil {
  5103  		l = m.Query.SizeVT()
  5104  		n += 1 + l + sov(uint64(l))
  5105  	}
  5106  	if m.Options != nil {
  5107  		l = m.Options.SizeVT()
  5108  		n += 1 + l + sov(uint64(l))
  5109  	}
  5110  	if len(m.PreQueries) > 0 {
  5111  		for _, s := range m.PreQueries {
  5112  			l = len(s)
  5113  			n += 1 + l + sov(uint64(l))
  5114  		}
  5115  	}
  5116  	if m.ReservedId != 0 {
  5117  		n += 1 + sov(uint64(m.ReservedId))
  5118  	}
  5119  	if m.unknownFields != nil {
  5120  		n += len(m.unknownFields)
  5121  	}
  5122  	return n
  5123  }
  5124  
  5125  func (m *BeginStreamExecuteResponse) SizeVT() (n int) {
  5126  	if m == nil {
  5127  		return 0
  5128  	}
  5129  	var l int
  5130  	_ = l
  5131  	if m.Error != nil {
  5132  		l = m.Error.SizeVT()
  5133  		n += 1 + l + sov(uint64(l))
  5134  	}
  5135  	if m.Result != nil {
  5136  		l = m.Result.SizeVT()
  5137  		n += 1 + l + sov(uint64(l))
  5138  	}
  5139  	if m.TransactionId != 0 {
  5140  		n += 1 + sov(uint64(m.TransactionId))
  5141  	}
  5142  	if m.TabletAlias != nil {
  5143  		l = m.TabletAlias.SizeVT()
  5144  		n += 1 + l + sov(uint64(l))
  5145  	}
  5146  	if m.unknownFields != nil {
  5147  		n += len(m.unknownFields)
  5148  	}
  5149  	return n
  5150  }
  5151  
  5152  func (m *MessageStreamRequest) SizeVT() (n int) {
  5153  	if m == nil {
  5154  		return 0
  5155  	}
  5156  	var l int
  5157  	_ = l
  5158  	if m.EffectiveCallerId != nil {
  5159  		l = m.EffectiveCallerId.SizeVT()
  5160  		n += 1 + l + sov(uint64(l))
  5161  	}
  5162  	if m.ImmediateCallerId != nil {
  5163  		l = m.ImmediateCallerId.SizeVT()
  5164  		n += 1 + l + sov(uint64(l))
  5165  	}
  5166  	if m.Target != nil {
  5167  		l = m.Target.SizeVT()
  5168  		n += 1 + l + sov(uint64(l))
  5169  	}
  5170  	l = len(m.Name)
  5171  	if l > 0 {
  5172  		n += 1 + l + sov(uint64(l))
  5173  	}
  5174  	if m.unknownFields != nil {
  5175  		n += len(m.unknownFields)
  5176  	}
  5177  	return n
  5178  }
  5179  
  5180  func (m *MessageStreamResponse) SizeVT() (n int) {
  5181  	if m == nil {
  5182  		return 0
  5183  	}
  5184  	var l int
  5185  	_ = l
  5186  	if m.Result != nil {
  5187  		l = m.Result.SizeVT()
  5188  		n += 1 + l + sov(uint64(l))
  5189  	}
  5190  	if m.unknownFields != nil {
  5191  		n += len(m.unknownFields)
  5192  	}
  5193  	return n
  5194  }
  5195  
  5196  func (m *MessageAckRequest) SizeVT() (n int) {
  5197  	if m == nil {
  5198  		return 0
  5199  	}
  5200  	var l int
  5201  	_ = l
  5202  	if m.EffectiveCallerId != nil {
  5203  		l = m.EffectiveCallerId.SizeVT()
  5204  		n += 1 + l + sov(uint64(l))
  5205  	}
  5206  	if m.ImmediateCallerId != nil {
  5207  		l = m.ImmediateCallerId.SizeVT()
  5208  		n += 1 + l + sov(uint64(l))
  5209  	}
  5210  	if m.Target != nil {
  5211  		l = m.Target.SizeVT()
  5212  		n += 1 + l + sov(uint64(l))
  5213  	}
  5214  	l = len(m.Name)
  5215  	if l > 0 {
  5216  		n += 1 + l + sov(uint64(l))
  5217  	}
  5218  	if len(m.Ids) > 0 {
  5219  		for _, e := range m.Ids {
  5220  			l = e.SizeVT()
  5221  			n += 1 + l + sov(uint64(l))
  5222  		}
  5223  	}
  5224  	if m.unknownFields != nil {
  5225  		n += len(m.unknownFields)
  5226  	}
  5227  	return n
  5228  }
  5229  
  5230  func (m *MessageAckResponse) SizeVT() (n int) {
  5231  	if m == nil {
  5232  		return 0
  5233  	}
  5234  	var l int
  5235  	_ = l
  5236  	if m.Result != nil {
  5237  		l = m.Result.SizeVT()
  5238  		n += 1 + l + sov(uint64(l))
  5239  	}
  5240  	if m.unknownFields != nil {
  5241  		n += len(m.unknownFields)
  5242  	}
  5243  	return n
  5244  }
  5245  
  5246  func (m *ReserveExecuteRequest) SizeVT() (n int) {
  5247  	if m == nil {
  5248  		return 0
  5249  	}
  5250  	var l int
  5251  	_ = l
  5252  	if m.EffectiveCallerId != nil {
  5253  		l = m.EffectiveCallerId.SizeVT()
  5254  		n += 1 + l + sov(uint64(l))
  5255  	}
  5256  	if m.ImmediateCallerId != nil {
  5257  		l = m.ImmediateCallerId.SizeVT()
  5258  		n += 1 + l + sov(uint64(l))
  5259  	}
  5260  	if m.Target != nil {
  5261  		l = m.Target.SizeVT()
  5262  		n += 1 + l + sov(uint64(l))
  5263  	}
  5264  	if m.Query != nil {
  5265  		l = m.Query.SizeVT()
  5266  		n += 1 + l + sov(uint64(l))
  5267  	}
  5268  	if m.TransactionId != 0 {
  5269  		n += 1 + sov(uint64(m.TransactionId))
  5270  	}
  5271  	if m.Options != nil {
  5272  		l = m.Options.SizeVT()
  5273  		n += 1 + l + sov(uint64(l))
  5274  	}
  5275  	if len(m.PreQueries) > 0 {
  5276  		for _, s := range m.PreQueries {
  5277  			l = len(s)
  5278  			n += 1 + l + sov(uint64(l))
  5279  		}
  5280  	}
  5281  	if m.unknownFields != nil {
  5282  		n += len(m.unknownFields)
  5283  	}
  5284  	return n
  5285  }
  5286  
  5287  func (m *ReserveExecuteResponse) SizeVT() (n int) {
  5288  	if m == nil {
  5289  		return 0
  5290  	}
  5291  	var l int
  5292  	_ = l
  5293  	if m.Error != nil {
  5294  		l = m.Error.SizeVT()
  5295  		n += 1 + l + sov(uint64(l))
  5296  	}
  5297  	if m.Result != nil {
  5298  		l = m.Result.SizeVT()
  5299  		n += 1 + l + sov(uint64(l))
  5300  	}
  5301  	if m.ReservedId != 0 {
  5302  		n += 1 + sov(uint64(m.ReservedId))
  5303  	}
  5304  	if m.TabletAlias != nil {
  5305  		l = m.TabletAlias.SizeVT()
  5306  		n += 1 + l + sov(uint64(l))
  5307  	}
  5308  	if m.unknownFields != nil {
  5309  		n += len(m.unknownFields)
  5310  	}
  5311  	return n
  5312  }
  5313  
  5314  func (m *ReserveStreamExecuteRequest) SizeVT() (n int) {
  5315  	if m == nil {
  5316  		return 0
  5317  	}
  5318  	var l int
  5319  	_ = l
  5320  	if m.EffectiveCallerId != nil {
  5321  		l = m.EffectiveCallerId.SizeVT()
  5322  		n += 1 + l + sov(uint64(l))
  5323  	}
  5324  	if m.ImmediateCallerId != nil {
  5325  		l = m.ImmediateCallerId.SizeVT()
  5326  		n += 1 + l + sov(uint64(l))
  5327  	}
  5328  	if m.Target != nil {
  5329  		l = m.Target.SizeVT()
  5330  		n += 1 + l + sov(uint64(l))
  5331  	}
  5332  	if m.Query != nil {
  5333  		l = m.Query.SizeVT()
  5334  		n += 1 + l + sov(uint64(l))
  5335  	}
  5336  	if m.Options != nil {
  5337  		l = m.Options.SizeVT()
  5338  		n += 1 + l + sov(uint64(l))
  5339  	}
  5340  	if m.TransactionId != 0 {
  5341  		n += 1 + sov(uint64(m.TransactionId))
  5342  	}
  5343  	if len(m.PreQueries) > 0 {
  5344  		for _, s := range m.PreQueries {
  5345  			l = len(s)
  5346  			n += 1 + l + sov(uint64(l))
  5347  		}
  5348  	}
  5349  	if m.unknownFields != nil {
  5350  		n += len(m.unknownFields)
  5351  	}
  5352  	return n
  5353  }
  5354  
  5355  func (m *ReserveStreamExecuteResponse) SizeVT() (n int) {
  5356  	if m == nil {
  5357  		return 0
  5358  	}
  5359  	var l int
  5360  	_ = l
  5361  	if m.Error != nil {
  5362  		l = m.Error.SizeVT()
  5363  		n += 1 + l + sov(uint64(l))
  5364  	}
  5365  	if m.Result != nil {
  5366  		l = m.Result.SizeVT()
  5367  		n += 1 + l + sov(uint64(l))
  5368  	}
  5369  	if m.ReservedId != 0 {
  5370  		n += 1 + sov(uint64(m.ReservedId))
  5371  	}
  5372  	if m.TabletAlias != nil {
  5373  		l = m.TabletAlias.SizeVT()
  5374  		n += 1 + l + sov(uint64(l))
  5375  	}
  5376  	if m.unknownFields != nil {
  5377  		n += len(m.unknownFields)
  5378  	}
  5379  	return n
  5380  }
  5381  
  5382  func (m *ReserveBeginExecuteRequest) SizeVT() (n int) {
  5383  	if m == nil {
  5384  		return 0
  5385  	}
  5386  	var l int
  5387  	_ = l
  5388  	if m.EffectiveCallerId != nil {
  5389  		l = m.EffectiveCallerId.SizeVT()
  5390  		n += 1 + l + sov(uint64(l))
  5391  	}
  5392  	if m.ImmediateCallerId != nil {
  5393  		l = m.ImmediateCallerId.SizeVT()
  5394  		n += 1 + l + sov(uint64(l))
  5395  	}
  5396  	if m.Target != nil {
  5397  		l = m.Target.SizeVT()
  5398  		n += 1 + l + sov(uint64(l))
  5399  	}
  5400  	if m.Query != nil {
  5401  		l = m.Query.SizeVT()
  5402  		n += 1 + l + sov(uint64(l))
  5403  	}
  5404  	if m.Options != nil {
  5405  		l = m.Options.SizeVT()
  5406  		n += 1 + l + sov(uint64(l))
  5407  	}
  5408  	if len(m.PreQueries) > 0 {
  5409  		for _, s := range m.PreQueries {
  5410  			l = len(s)
  5411  			n += 1 + l + sov(uint64(l))
  5412  		}
  5413  	}
  5414  	if len(m.PostBeginQueries) > 0 {
  5415  		for _, s := range m.PostBeginQueries {
  5416  			l = len(s)
  5417  			n += 1 + l + sov(uint64(l))
  5418  		}
  5419  	}
  5420  	if m.unknownFields != nil {
  5421  		n += len(m.unknownFields)
  5422  	}
  5423  	return n
  5424  }
  5425  
  5426  func (m *ReserveBeginExecuteResponse) SizeVT() (n int) {
  5427  	if m == nil {
  5428  		return 0
  5429  	}
  5430  	var l int
  5431  	_ = l
  5432  	if m.Error != nil {
  5433  		l = m.Error.SizeVT()
  5434  		n += 1 + l + sov(uint64(l))
  5435  	}
  5436  	if m.Result != nil {
  5437  		l = m.Result.SizeVT()
  5438  		n += 1 + l + sov(uint64(l))
  5439  	}
  5440  	if m.TransactionId != 0 {
  5441  		n += 1 + sov(uint64(m.TransactionId))
  5442  	}
  5443  	if m.ReservedId != 0 {
  5444  		n += 1 + sov(uint64(m.ReservedId))
  5445  	}
  5446  	if m.TabletAlias != nil {
  5447  		l = m.TabletAlias.SizeVT()
  5448  		n += 1 + l + sov(uint64(l))
  5449  	}
  5450  	if m.unknownFields != nil {
  5451  		n += len(m.unknownFields)
  5452  	}
  5453  	return n
  5454  }
  5455  
  5456  func (m *ReserveBeginStreamExecuteRequest) SizeVT() (n int) {
  5457  	if m == nil {
  5458  		return 0
  5459  	}
  5460  	var l int
  5461  	_ = l
  5462  	if m.EffectiveCallerId != nil {
  5463  		l = m.EffectiveCallerId.SizeVT()
  5464  		n += 1 + l + sov(uint64(l))
  5465  	}
  5466  	if m.ImmediateCallerId != nil {
  5467  		l = m.ImmediateCallerId.SizeVT()
  5468  		n += 1 + l + sov(uint64(l))
  5469  	}
  5470  	if m.Target != nil {
  5471  		l = m.Target.SizeVT()
  5472  		n += 1 + l + sov(uint64(l))
  5473  	}
  5474  	if m.Query != nil {
  5475  		l = m.Query.SizeVT()
  5476  		n += 1 + l + sov(uint64(l))
  5477  	}
  5478  	if m.Options != nil {
  5479  		l = m.Options.SizeVT()
  5480  		n += 1 + l + sov(uint64(l))
  5481  	}
  5482  	if len(m.PreQueries) > 0 {
  5483  		for _, s := range m.PreQueries {
  5484  			l = len(s)
  5485  			n += 1 + l + sov(uint64(l))
  5486  		}
  5487  	}
  5488  	if len(m.PostBeginQueries) > 0 {
  5489  		for _, s := range m.PostBeginQueries {
  5490  			l = len(s)
  5491  			n += 1 + l + sov(uint64(l))
  5492  		}
  5493  	}
  5494  	if m.unknownFields != nil {
  5495  		n += len(m.unknownFields)
  5496  	}
  5497  	return n
  5498  }
  5499  
  5500  func (m *ReserveBeginStreamExecuteResponse) SizeVT() (n int) {
  5501  	if m == nil {
  5502  		return 0
  5503  	}
  5504  	var l int
  5505  	_ = l
  5506  	if m.Error != nil {
  5507  		l = m.Error.SizeVT()
  5508  		n += 1 + l + sov(uint64(l))
  5509  	}
  5510  	if m.Result != nil {
  5511  		l = m.Result.SizeVT()
  5512  		n += 1 + l + sov(uint64(l))
  5513  	}
  5514  	if m.TransactionId != 0 {
  5515  		n += 1 + sov(uint64(m.TransactionId))
  5516  	}
  5517  	if m.ReservedId != 0 {
  5518  		n += 1 + sov(uint64(m.ReservedId))
  5519  	}
  5520  	if m.TabletAlias != nil {
  5521  		l = m.TabletAlias.SizeVT()
  5522  		n += 1 + l + sov(uint64(l))
  5523  	}
  5524  	if m.unknownFields != nil {
  5525  		n += len(m.unknownFields)
  5526  	}
  5527  	return n
  5528  }
  5529  
  5530  func (m *ReleaseRequest) SizeVT() (n int) {
  5531  	if m == nil {
  5532  		return 0
  5533  	}
  5534  	var l int
  5535  	_ = l
  5536  	if m.EffectiveCallerId != nil {
  5537  		l = m.EffectiveCallerId.SizeVT()
  5538  		n += 1 + l + sov(uint64(l))
  5539  	}
  5540  	if m.ImmediateCallerId != nil {
  5541  		l = m.ImmediateCallerId.SizeVT()
  5542  		n += 1 + l + sov(uint64(l))
  5543  	}
  5544  	if m.Target != nil {
  5545  		l = m.Target.SizeVT()
  5546  		n += 1 + l + sov(uint64(l))
  5547  	}
  5548  	if m.TransactionId != 0 {
  5549  		n += 1 + sov(uint64(m.TransactionId))
  5550  	}
  5551  	if m.ReservedId != 0 {
  5552  		n += 1 + sov(uint64(m.ReservedId))
  5553  	}
  5554  	if m.unknownFields != nil {
  5555  		n += len(m.unknownFields)
  5556  	}
  5557  	return n
  5558  }
  5559  
  5560  func (m *ReleaseResponse) SizeVT() (n int) {
  5561  	if m == nil {
  5562  		return 0
  5563  	}
  5564  	var l int
  5565  	_ = l
  5566  	if m.unknownFields != nil {
  5567  		n += len(m.unknownFields)
  5568  	}
  5569  	return n
  5570  }
  5571  
  5572  func (m *StreamHealthRequest) SizeVT() (n int) {
  5573  	if m == nil {
  5574  		return 0
  5575  	}
  5576  	var l int
  5577  	_ = l
  5578  	if m.unknownFields != nil {
  5579  		n += len(m.unknownFields)
  5580  	}
  5581  	return n
  5582  }
  5583  
  5584  func (m *RealtimeStats) SizeVT() (n int) {
  5585  	if m == nil {
  5586  		return 0
  5587  	}
  5588  	var l int
  5589  	_ = l
  5590  	l = len(m.HealthError)
  5591  	if l > 0 {
  5592  		n += 1 + l + sov(uint64(l))
  5593  	}
  5594  	if m.ReplicationLagSeconds != 0 {
  5595  		n += 1 + sov(uint64(m.ReplicationLagSeconds))
  5596  	}
  5597  	if m.BinlogPlayersCount != 0 {
  5598  		n += 1 + sov(uint64(m.BinlogPlayersCount))
  5599  	}
  5600  	if m.FilteredReplicationLagSeconds != 0 {
  5601  		n += 1 + sov(uint64(m.FilteredReplicationLagSeconds))
  5602  	}
  5603  	if m.CpuUsage != 0 {
  5604  		n += 9
  5605  	}
  5606  	if m.Qps != 0 {
  5607  		n += 9
  5608  	}
  5609  	if len(m.TableSchemaChanged) > 0 {
  5610  		for _, s := range m.TableSchemaChanged {
  5611  			l = len(s)
  5612  			n += 1 + l + sov(uint64(l))
  5613  		}
  5614  	}
  5615  	if m.unknownFields != nil {
  5616  		n += len(m.unknownFields)
  5617  	}
  5618  	return n
  5619  }
  5620  
  5621  func (m *AggregateStats) SizeVT() (n int) {
  5622  	if m == nil {
  5623  		return 0
  5624  	}
  5625  	var l int
  5626  	_ = l
  5627  	if m.HealthyTabletCount != 0 {
  5628  		n += 1 + sov(uint64(m.HealthyTabletCount))
  5629  	}
  5630  	if m.UnhealthyTabletCount != 0 {
  5631  		n += 1 + sov(uint64(m.UnhealthyTabletCount))
  5632  	}
  5633  	if m.ReplicationLagSecondsMin != 0 {
  5634  		n += 1 + sov(uint64(m.ReplicationLagSecondsMin))
  5635  	}
  5636  	if m.ReplicationLagSecondsMax != 0 {
  5637  		n += 1 + sov(uint64(m.ReplicationLagSecondsMax))
  5638  	}
  5639  	if m.unknownFields != nil {
  5640  		n += len(m.unknownFields)
  5641  	}
  5642  	return n
  5643  }
  5644  
  5645  func (m *StreamHealthResponse) SizeVT() (n int) {
  5646  	if m == nil {
  5647  		return 0
  5648  	}
  5649  	var l int
  5650  	_ = l
  5651  	if m.Target != nil {
  5652  		l = m.Target.SizeVT()
  5653  		n += 1 + l + sov(uint64(l))
  5654  	}
  5655  	if m.Serving {
  5656  		n += 2
  5657  	}
  5658  	if m.TabletExternallyReparentedTimestamp != 0 {
  5659  		n += 1 + sov(uint64(m.TabletExternallyReparentedTimestamp))
  5660  	}
  5661  	if m.RealtimeStats != nil {
  5662  		l = m.RealtimeStats.SizeVT()
  5663  		n += 1 + l + sov(uint64(l))
  5664  	}
  5665  	if m.TabletAlias != nil {
  5666  		l = m.TabletAlias.SizeVT()
  5667  		n += 1 + l + sov(uint64(l))
  5668  	}
  5669  	if m.unknownFields != nil {
  5670  		n += len(m.unknownFields)
  5671  	}
  5672  	return n
  5673  }
  5674  
  5675  func (m *TransactionMetadata) SizeVT() (n int) {
  5676  	if m == nil {
  5677  		return 0
  5678  	}
  5679  	var l int
  5680  	_ = l
  5681  	l = len(m.Dtid)
  5682  	if l > 0 {
  5683  		n += 1 + l + sov(uint64(l))
  5684  	}
  5685  	if m.State != 0 {
  5686  		n += 1 + sov(uint64(m.State))
  5687  	}
  5688  	if m.TimeCreated != 0 {
  5689  		n += 1 + sov(uint64(m.TimeCreated))
  5690  	}
  5691  	if len(m.Participants) > 0 {
  5692  		for _, e := range m.Participants {
  5693  			l = e.SizeVT()
  5694  			n += 1 + l + sov(uint64(l))
  5695  		}
  5696  	}
  5697  	if m.unknownFields != nil {
  5698  		n += len(m.unknownFields)
  5699  	}
  5700  	return n
  5701  }
  5702  
  5703  func sov(x uint64) (n int) {
  5704  	return (bits.Len64(x|1) + 6) / 7
  5705  }
  5706  func soz(x uint64) (n int) {
  5707  	return sov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  5708  }
  5709  func (m *Target) UnmarshalVT(dAtA []byte) error {
  5710  	l := len(dAtA)
  5711  	iNdEx := 0
  5712  	for iNdEx < l {
  5713  		preIndex := iNdEx
  5714  		var wire uint64
  5715  		for shift := uint(0); ; shift += 7 {
  5716  			if shift >= 64 {
  5717  				return ErrIntOverflow
  5718  			}
  5719  			if iNdEx >= l {
  5720  				return io.ErrUnexpectedEOF
  5721  			}
  5722  			b := dAtA[iNdEx]
  5723  			iNdEx++
  5724  			wire |= uint64(b&0x7F) << shift
  5725  			if b < 0x80 {
  5726  				break
  5727  			}
  5728  		}
  5729  		fieldNum := int32(wire >> 3)
  5730  		wireType := int(wire & 0x7)
  5731  		if wireType == 4 {
  5732  			return fmt.Errorf("proto: Target: wiretype end group for non-group")
  5733  		}
  5734  		if fieldNum <= 0 {
  5735  			return fmt.Errorf("proto: Target: illegal tag %d (wire type %d)", fieldNum, wire)
  5736  		}
  5737  		switch fieldNum {
  5738  		case 1:
  5739  			if wireType != 2 {
  5740  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
  5741  			}
  5742  			var stringLen uint64
  5743  			for shift := uint(0); ; shift += 7 {
  5744  				if shift >= 64 {
  5745  					return ErrIntOverflow
  5746  				}
  5747  				if iNdEx >= l {
  5748  					return io.ErrUnexpectedEOF
  5749  				}
  5750  				b := dAtA[iNdEx]
  5751  				iNdEx++
  5752  				stringLen |= uint64(b&0x7F) << shift
  5753  				if b < 0x80 {
  5754  					break
  5755  				}
  5756  			}
  5757  			intStringLen := int(stringLen)
  5758  			if intStringLen < 0 {
  5759  				return ErrInvalidLength
  5760  			}
  5761  			postIndex := iNdEx + intStringLen
  5762  			if postIndex < 0 {
  5763  				return ErrInvalidLength
  5764  			}
  5765  			if postIndex > l {
  5766  				return io.ErrUnexpectedEOF
  5767  			}
  5768  			m.Keyspace = string(dAtA[iNdEx:postIndex])
  5769  			iNdEx = postIndex
  5770  		case 2:
  5771  			if wireType != 2 {
  5772  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
  5773  			}
  5774  			var stringLen uint64
  5775  			for shift := uint(0); ; shift += 7 {
  5776  				if shift >= 64 {
  5777  					return ErrIntOverflow
  5778  				}
  5779  				if iNdEx >= l {
  5780  					return io.ErrUnexpectedEOF
  5781  				}
  5782  				b := dAtA[iNdEx]
  5783  				iNdEx++
  5784  				stringLen |= uint64(b&0x7F) << shift
  5785  				if b < 0x80 {
  5786  					break
  5787  				}
  5788  			}
  5789  			intStringLen := int(stringLen)
  5790  			if intStringLen < 0 {
  5791  				return ErrInvalidLength
  5792  			}
  5793  			postIndex := iNdEx + intStringLen
  5794  			if postIndex < 0 {
  5795  				return ErrInvalidLength
  5796  			}
  5797  			if postIndex > l {
  5798  				return io.ErrUnexpectedEOF
  5799  			}
  5800  			m.Shard = string(dAtA[iNdEx:postIndex])
  5801  			iNdEx = postIndex
  5802  		case 3:
  5803  			if wireType != 0 {
  5804  				return fmt.Errorf("proto: wrong wireType = %d for field TabletType", wireType)
  5805  			}
  5806  			m.TabletType = 0
  5807  			for shift := uint(0); ; shift += 7 {
  5808  				if shift >= 64 {
  5809  					return ErrIntOverflow
  5810  				}
  5811  				if iNdEx >= l {
  5812  					return io.ErrUnexpectedEOF
  5813  				}
  5814  				b := dAtA[iNdEx]
  5815  				iNdEx++
  5816  				m.TabletType |= topodata.TabletType(b&0x7F) << shift
  5817  				if b < 0x80 {
  5818  					break
  5819  				}
  5820  			}
  5821  		case 4:
  5822  			if wireType != 2 {
  5823  				return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType)
  5824  			}
  5825  			var stringLen uint64
  5826  			for shift := uint(0); ; shift += 7 {
  5827  				if shift >= 64 {
  5828  					return ErrIntOverflow
  5829  				}
  5830  				if iNdEx >= l {
  5831  					return io.ErrUnexpectedEOF
  5832  				}
  5833  				b := dAtA[iNdEx]
  5834  				iNdEx++
  5835  				stringLen |= uint64(b&0x7F) << shift
  5836  				if b < 0x80 {
  5837  					break
  5838  				}
  5839  			}
  5840  			intStringLen := int(stringLen)
  5841  			if intStringLen < 0 {
  5842  				return ErrInvalidLength
  5843  			}
  5844  			postIndex := iNdEx + intStringLen
  5845  			if postIndex < 0 {
  5846  				return ErrInvalidLength
  5847  			}
  5848  			if postIndex > l {
  5849  				return io.ErrUnexpectedEOF
  5850  			}
  5851  			m.Cell = string(dAtA[iNdEx:postIndex])
  5852  			iNdEx = postIndex
  5853  		default:
  5854  			iNdEx = preIndex
  5855  			skippy, err := skip(dAtA[iNdEx:])
  5856  			if err != nil {
  5857  				return err
  5858  			}
  5859  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5860  				return ErrInvalidLength
  5861  			}
  5862  			if (iNdEx + skippy) > l {
  5863  				return io.ErrUnexpectedEOF
  5864  			}
  5865  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  5866  			iNdEx += skippy
  5867  		}
  5868  	}
  5869  
  5870  	if iNdEx > l {
  5871  		return io.ErrUnexpectedEOF
  5872  	}
  5873  	return nil
  5874  }
  5875  func (m *VTGateCallerID) UnmarshalVT(dAtA []byte) error {
  5876  	l := len(dAtA)
  5877  	iNdEx := 0
  5878  	for iNdEx < l {
  5879  		preIndex := iNdEx
  5880  		var wire uint64
  5881  		for shift := uint(0); ; shift += 7 {
  5882  			if shift >= 64 {
  5883  				return ErrIntOverflow
  5884  			}
  5885  			if iNdEx >= l {
  5886  				return io.ErrUnexpectedEOF
  5887  			}
  5888  			b := dAtA[iNdEx]
  5889  			iNdEx++
  5890  			wire |= uint64(b&0x7F) << shift
  5891  			if b < 0x80 {
  5892  				break
  5893  			}
  5894  		}
  5895  		fieldNum := int32(wire >> 3)
  5896  		wireType := int(wire & 0x7)
  5897  		if wireType == 4 {
  5898  			return fmt.Errorf("proto: VTGateCallerID: wiretype end group for non-group")
  5899  		}
  5900  		if fieldNum <= 0 {
  5901  			return fmt.Errorf("proto: VTGateCallerID: illegal tag %d (wire type %d)", fieldNum, wire)
  5902  		}
  5903  		switch fieldNum {
  5904  		case 1:
  5905  			if wireType != 2 {
  5906  				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
  5907  			}
  5908  			var stringLen uint64
  5909  			for shift := uint(0); ; shift += 7 {
  5910  				if shift >= 64 {
  5911  					return ErrIntOverflow
  5912  				}
  5913  				if iNdEx >= l {
  5914  					return io.ErrUnexpectedEOF
  5915  				}
  5916  				b := dAtA[iNdEx]
  5917  				iNdEx++
  5918  				stringLen |= uint64(b&0x7F) << shift
  5919  				if b < 0x80 {
  5920  					break
  5921  				}
  5922  			}
  5923  			intStringLen := int(stringLen)
  5924  			if intStringLen < 0 {
  5925  				return ErrInvalidLength
  5926  			}
  5927  			postIndex := iNdEx + intStringLen
  5928  			if postIndex < 0 {
  5929  				return ErrInvalidLength
  5930  			}
  5931  			if postIndex > l {
  5932  				return io.ErrUnexpectedEOF
  5933  			}
  5934  			m.Username = string(dAtA[iNdEx:postIndex])
  5935  			iNdEx = postIndex
  5936  		case 2:
  5937  			if wireType != 2 {
  5938  				return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
  5939  			}
  5940  			var stringLen uint64
  5941  			for shift := uint(0); ; shift += 7 {
  5942  				if shift >= 64 {
  5943  					return ErrIntOverflow
  5944  				}
  5945  				if iNdEx >= l {
  5946  					return io.ErrUnexpectedEOF
  5947  				}
  5948  				b := dAtA[iNdEx]
  5949  				iNdEx++
  5950  				stringLen |= uint64(b&0x7F) << shift
  5951  				if b < 0x80 {
  5952  					break
  5953  				}
  5954  			}
  5955  			intStringLen := int(stringLen)
  5956  			if intStringLen < 0 {
  5957  				return ErrInvalidLength
  5958  			}
  5959  			postIndex := iNdEx + intStringLen
  5960  			if postIndex < 0 {
  5961  				return ErrInvalidLength
  5962  			}
  5963  			if postIndex > l {
  5964  				return io.ErrUnexpectedEOF
  5965  			}
  5966  			m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex]))
  5967  			iNdEx = postIndex
  5968  		default:
  5969  			iNdEx = preIndex
  5970  			skippy, err := skip(dAtA[iNdEx:])
  5971  			if err != nil {
  5972  				return err
  5973  			}
  5974  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5975  				return ErrInvalidLength
  5976  			}
  5977  			if (iNdEx + skippy) > l {
  5978  				return io.ErrUnexpectedEOF
  5979  			}
  5980  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  5981  			iNdEx += skippy
  5982  		}
  5983  	}
  5984  
  5985  	if iNdEx > l {
  5986  		return io.ErrUnexpectedEOF
  5987  	}
  5988  	return nil
  5989  }
  5990  func (m *EventToken) UnmarshalVT(dAtA []byte) error {
  5991  	l := len(dAtA)
  5992  	iNdEx := 0
  5993  	for iNdEx < l {
  5994  		preIndex := iNdEx
  5995  		var wire uint64
  5996  		for shift := uint(0); ; shift += 7 {
  5997  			if shift >= 64 {
  5998  				return ErrIntOverflow
  5999  			}
  6000  			if iNdEx >= l {
  6001  				return io.ErrUnexpectedEOF
  6002  			}
  6003  			b := dAtA[iNdEx]
  6004  			iNdEx++
  6005  			wire |= uint64(b&0x7F) << shift
  6006  			if b < 0x80 {
  6007  				break
  6008  			}
  6009  		}
  6010  		fieldNum := int32(wire >> 3)
  6011  		wireType := int(wire & 0x7)
  6012  		if wireType == 4 {
  6013  			return fmt.Errorf("proto: EventToken: wiretype end group for non-group")
  6014  		}
  6015  		if fieldNum <= 0 {
  6016  			return fmt.Errorf("proto: EventToken: illegal tag %d (wire type %d)", fieldNum, wire)
  6017  		}
  6018  		switch fieldNum {
  6019  		case 1:
  6020  			if wireType != 0 {
  6021  				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
  6022  			}
  6023  			m.Timestamp = 0
  6024  			for shift := uint(0); ; shift += 7 {
  6025  				if shift >= 64 {
  6026  					return ErrIntOverflow
  6027  				}
  6028  				if iNdEx >= l {
  6029  					return io.ErrUnexpectedEOF
  6030  				}
  6031  				b := dAtA[iNdEx]
  6032  				iNdEx++
  6033  				m.Timestamp |= int64(b&0x7F) << shift
  6034  				if b < 0x80 {
  6035  					break
  6036  				}
  6037  			}
  6038  		case 2:
  6039  			if wireType != 2 {
  6040  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
  6041  			}
  6042  			var stringLen uint64
  6043  			for shift := uint(0); ; shift += 7 {
  6044  				if shift >= 64 {
  6045  					return ErrIntOverflow
  6046  				}
  6047  				if iNdEx >= l {
  6048  					return io.ErrUnexpectedEOF
  6049  				}
  6050  				b := dAtA[iNdEx]
  6051  				iNdEx++
  6052  				stringLen |= uint64(b&0x7F) << shift
  6053  				if b < 0x80 {
  6054  					break
  6055  				}
  6056  			}
  6057  			intStringLen := int(stringLen)
  6058  			if intStringLen < 0 {
  6059  				return ErrInvalidLength
  6060  			}
  6061  			postIndex := iNdEx + intStringLen
  6062  			if postIndex < 0 {
  6063  				return ErrInvalidLength
  6064  			}
  6065  			if postIndex > l {
  6066  				return io.ErrUnexpectedEOF
  6067  			}
  6068  			m.Shard = string(dAtA[iNdEx:postIndex])
  6069  			iNdEx = postIndex
  6070  		case 3:
  6071  			if wireType != 2 {
  6072  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
  6073  			}
  6074  			var stringLen uint64
  6075  			for shift := uint(0); ; shift += 7 {
  6076  				if shift >= 64 {
  6077  					return ErrIntOverflow
  6078  				}
  6079  				if iNdEx >= l {
  6080  					return io.ErrUnexpectedEOF
  6081  				}
  6082  				b := dAtA[iNdEx]
  6083  				iNdEx++
  6084  				stringLen |= uint64(b&0x7F) << shift
  6085  				if b < 0x80 {
  6086  					break
  6087  				}
  6088  			}
  6089  			intStringLen := int(stringLen)
  6090  			if intStringLen < 0 {
  6091  				return ErrInvalidLength
  6092  			}
  6093  			postIndex := iNdEx + intStringLen
  6094  			if postIndex < 0 {
  6095  				return ErrInvalidLength
  6096  			}
  6097  			if postIndex > l {
  6098  				return io.ErrUnexpectedEOF
  6099  			}
  6100  			m.Position = string(dAtA[iNdEx:postIndex])
  6101  			iNdEx = postIndex
  6102  		default:
  6103  			iNdEx = preIndex
  6104  			skippy, err := skip(dAtA[iNdEx:])
  6105  			if err != nil {
  6106  				return err
  6107  			}
  6108  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6109  				return ErrInvalidLength
  6110  			}
  6111  			if (iNdEx + skippy) > l {
  6112  				return io.ErrUnexpectedEOF
  6113  			}
  6114  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6115  			iNdEx += skippy
  6116  		}
  6117  	}
  6118  
  6119  	if iNdEx > l {
  6120  		return io.ErrUnexpectedEOF
  6121  	}
  6122  	return nil
  6123  }
  6124  func (m *Value) UnmarshalVT(dAtA []byte) error {
  6125  	l := len(dAtA)
  6126  	iNdEx := 0
  6127  	for iNdEx < l {
  6128  		preIndex := iNdEx
  6129  		var wire uint64
  6130  		for shift := uint(0); ; shift += 7 {
  6131  			if shift >= 64 {
  6132  				return ErrIntOverflow
  6133  			}
  6134  			if iNdEx >= l {
  6135  				return io.ErrUnexpectedEOF
  6136  			}
  6137  			b := dAtA[iNdEx]
  6138  			iNdEx++
  6139  			wire |= uint64(b&0x7F) << shift
  6140  			if b < 0x80 {
  6141  				break
  6142  			}
  6143  		}
  6144  		fieldNum := int32(wire >> 3)
  6145  		wireType := int(wire & 0x7)
  6146  		if wireType == 4 {
  6147  			return fmt.Errorf("proto: Value: wiretype end group for non-group")
  6148  		}
  6149  		if fieldNum <= 0 {
  6150  			return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire)
  6151  		}
  6152  		switch fieldNum {
  6153  		case 1:
  6154  			if wireType != 0 {
  6155  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  6156  			}
  6157  			m.Type = 0
  6158  			for shift := uint(0); ; shift += 7 {
  6159  				if shift >= 64 {
  6160  					return ErrIntOverflow
  6161  				}
  6162  				if iNdEx >= l {
  6163  					return io.ErrUnexpectedEOF
  6164  				}
  6165  				b := dAtA[iNdEx]
  6166  				iNdEx++
  6167  				m.Type |= Type(b&0x7F) << shift
  6168  				if b < 0x80 {
  6169  					break
  6170  				}
  6171  			}
  6172  		case 2:
  6173  			if wireType != 2 {
  6174  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  6175  			}
  6176  			var byteLen int
  6177  			for shift := uint(0); ; shift += 7 {
  6178  				if shift >= 64 {
  6179  					return ErrIntOverflow
  6180  				}
  6181  				if iNdEx >= l {
  6182  					return io.ErrUnexpectedEOF
  6183  				}
  6184  				b := dAtA[iNdEx]
  6185  				iNdEx++
  6186  				byteLen |= int(b&0x7F) << shift
  6187  				if b < 0x80 {
  6188  					break
  6189  				}
  6190  			}
  6191  			if byteLen < 0 {
  6192  				return ErrInvalidLength
  6193  			}
  6194  			postIndex := iNdEx + byteLen
  6195  			if postIndex < 0 {
  6196  				return ErrInvalidLength
  6197  			}
  6198  			if postIndex > l {
  6199  				return io.ErrUnexpectedEOF
  6200  			}
  6201  			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
  6202  			if m.Value == nil {
  6203  				m.Value = []byte{}
  6204  			}
  6205  			iNdEx = postIndex
  6206  		default:
  6207  			iNdEx = preIndex
  6208  			skippy, err := skip(dAtA[iNdEx:])
  6209  			if err != nil {
  6210  				return err
  6211  			}
  6212  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6213  				return ErrInvalidLength
  6214  			}
  6215  			if (iNdEx + skippy) > l {
  6216  				return io.ErrUnexpectedEOF
  6217  			}
  6218  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6219  			iNdEx += skippy
  6220  		}
  6221  	}
  6222  
  6223  	if iNdEx > l {
  6224  		return io.ErrUnexpectedEOF
  6225  	}
  6226  	return nil
  6227  }
  6228  func (m *BindVariable) UnmarshalVT(dAtA []byte) error {
  6229  	l := len(dAtA)
  6230  	iNdEx := 0
  6231  	for iNdEx < l {
  6232  		preIndex := iNdEx
  6233  		var wire uint64
  6234  		for shift := uint(0); ; shift += 7 {
  6235  			if shift >= 64 {
  6236  				return ErrIntOverflow
  6237  			}
  6238  			if iNdEx >= l {
  6239  				return io.ErrUnexpectedEOF
  6240  			}
  6241  			b := dAtA[iNdEx]
  6242  			iNdEx++
  6243  			wire |= uint64(b&0x7F) << shift
  6244  			if b < 0x80 {
  6245  				break
  6246  			}
  6247  		}
  6248  		fieldNum := int32(wire >> 3)
  6249  		wireType := int(wire & 0x7)
  6250  		if wireType == 4 {
  6251  			return fmt.Errorf("proto: BindVariable: wiretype end group for non-group")
  6252  		}
  6253  		if fieldNum <= 0 {
  6254  			return fmt.Errorf("proto: BindVariable: illegal tag %d (wire type %d)", fieldNum, wire)
  6255  		}
  6256  		switch fieldNum {
  6257  		case 1:
  6258  			if wireType != 0 {
  6259  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  6260  			}
  6261  			m.Type = 0
  6262  			for shift := uint(0); ; shift += 7 {
  6263  				if shift >= 64 {
  6264  					return ErrIntOverflow
  6265  				}
  6266  				if iNdEx >= l {
  6267  					return io.ErrUnexpectedEOF
  6268  				}
  6269  				b := dAtA[iNdEx]
  6270  				iNdEx++
  6271  				m.Type |= Type(b&0x7F) << shift
  6272  				if b < 0x80 {
  6273  					break
  6274  				}
  6275  			}
  6276  		case 2:
  6277  			if wireType != 2 {
  6278  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  6279  			}
  6280  			var byteLen int
  6281  			for shift := uint(0); ; shift += 7 {
  6282  				if shift >= 64 {
  6283  					return ErrIntOverflow
  6284  				}
  6285  				if iNdEx >= l {
  6286  					return io.ErrUnexpectedEOF
  6287  				}
  6288  				b := dAtA[iNdEx]
  6289  				iNdEx++
  6290  				byteLen |= int(b&0x7F) << shift
  6291  				if b < 0x80 {
  6292  					break
  6293  				}
  6294  			}
  6295  			if byteLen < 0 {
  6296  				return ErrInvalidLength
  6297  			}
  6298  			postIndex := iNdEx + byteLen
  6299  			if postIndex < 0 {
  6300  				return ErrInvalidLength
  6301  			}
  6302  			if postIndex > l {
  6303  				return io.ErrUnexpectedEOF
  6304  			}
  6305  			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
  6306  			if m.Value == nil {
  6307  				m.Value = []byte{}
  6308  			}
  6309  			iNdEx = postIndex
  6310  		case 3:
  6311  			if wireType != 2 {
  6312  				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
  6313  			}
  6314  			var msglen int
  6315  			for shift := uint(0); ; shift += 7 {
  6316  				if shift >= 64 {
  6317  					return ErrIntOverflow
  6318  				}
  6319  				if iNdEx >= l {
  6320  					return io.ErrUnexpectedEOF
  6321  				}
  6322  				b := dAtA[iNdEx]
  6323  				iNdEx++
  6324  				msglen |= int(b&0x7F) << shift
  6325  				if b < 0x80 {
  6326  					break
  6327  				}
  6328  			}
  6329  			if msglen < 0 {
  6330  				return ErrInvalidLength
  6331  			}
  6332  			postIndex := iNdEx + msglen
  6333  			if postIndex < 0 {
  6334  				return ErrInvalidLength
  6335  			}
  6336  			if postIndex > l {
  6337  				return io.ErrUnexpectedEOF
  6338  			}
  6339  			m.Values = append(m.Values, &Value{})
  6340  			if err := m.Values[len(m.Values)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  6341  				return err
  6342  			}
  6343  			iNdEx = postIndex
  6344  		default:
  6345  			iNdEx = preIndex
  6346  			skippy, err := skip(dAtA[iNdEx:])
  6347  			if err != nil {
  6348  				return err
  6349  			}
  6350  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6351  				return ErrInvalidLength
  6352  			}
  6353  			if (iNdEx + skippy) > l {
  6354  				return io.ErrUnexpectedEOF
  6355  			}
  6356  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6357  			iNdEx += skippy
  6358  		}
  6359  	}
  6360  
  6361  	if iNdEx > l {
  6362  		return io.ErrUnexpectedEOF
  6363  	}
  6364  	return nil
  6365  }
  6366  func (m *BoundQuery) UnmarshalVT(dAtA []byte) error {
  6367  	l := len(dAtA)
  6368  	iNdEx := 0
  6369  	for iNdEx < l {
  6370  		preIndex := iNdEx
  6371  		var wire uint64
  6372  		for shift := uint(0); ; shift += 7 {
  6373  			if shift >= 64 {
  6374  				return ErrIntOverflow
  6375  			}
  6376  			if iNdEx >= l {
  6377  				return io.ErrUnexpectedEOF
  6378  			}
  6379  			b := dAtA[iNdEx]
  6380  			iNdEx++
  6381  			wire |= uint64(b&0x7F) << shift
  6382  			if b < 0x80 {
  6383  				break
  6384  			}
  6385  		}
  6386  		fieldNum := int32(wire >> 3)
  6387  		wireType := int(wire & 0x7)
  6388  		if wireType == 4 {
  6389  			return fmt.Errorf("proto: BoundQuery: wiretype end group for non-group")
  6390  		}
  6391  		if fieldNum <= 0 {
  6392  			return fmt.Errorf("proto: BoundQuery: illegal tag %d (wire type %d)", fieldNum, wire)
  6393  		}
  6394  		switch fieldNum {
  6395  		case 1:
  6396  			if wireType != 2 {
  6397  				return fmt.Errorf("proto: wrong wireType = %d for field Sql", wireType)
  6398  			}
  6399  			var stringLen uint64
  6400  			for shift := uint(0); ; shift += 7 {
  6401  				if shift >= 64 {
  6402  					return ErrIntOverflow
  6403  				}
  6404  				if iNdEx >= l {
  6405  					return io.ErrUnexpectedEOF
  6406  				}
  6407  				b := dAtA[iNdEx]
  6408  				iNdEx++
  6409  				stringLen |= uint64(b&0x7F) << shift
  6410  				if b < 0x80 {
  6411  					break
  6412  				}
  6413  			}
  6414  			intStringLen := int(stringLen)
  6415  			if intStringLen < 0 {
  6416  				return ErrInvalidLength
  6417  			}
  6418  			postIndex := iNdEx + intStringLen
  6419  			if postIndex < 0 {
  6420  				return ErrInvalidLength
  6421  			}
  6422  			if postIndex > l {
  6423  				return io.ErrUnexpectedEOF
  6424  			}
  6425  			m.Sql = string(dAtA[iNdEx:postIndex])
  6426  			iNdEx = postIndex
  6427  		case 2:
  6428  			if wireType != 2 {
  6429  				return fmt.Errorf("proto: wrong wireType = %d for field BindVariables", wireType)
  6430  			}
  6431  			var msglen int
  6432  			for shift := uint(0); ; shift += 7 {
  6433  				if shift >= 64 {
  6434  					return ErrIntOverflow
  6435  				}
  6436  				if iNdEx >= l {
  6437  					return io.ErrUnexpectedEOF
  6438  				}
  6439  				b := dAtA[iNdEx]
  6440  				iNdEx++
  6441  				msglen |= int(b&0x7F) << shift
  6442  				if b < 0x80 {
  6443  					break
  6444  				}
  6445  			}
  6446  			if msglen < 0 {
  6447  				return ErrInvalidLength
  6448  			}
  6449  			postIndex := iNdEx + msglen
  6450  			if postIndex < 0 {
  6451  				return ErrInvalidLength
  6452  			}
  6453  			if postIndex > l {
  6454  				return io.ErrUnexpectedEOF
  6455  			}
  6456  			if m.BindVariables == nil {
  6457  				m.BindVariables = make(map[string]*BindVariable)
  6458  			}
  6459  			var mapkey string
  6460  			var mapvalue *BindVariable
  6461  			for iNdEx < postIndex {
  6462  				entryPreIndex := iNdEx
  6463  				var wire uint64
  6464  				for shift := uint(0); ; shift += 7 {
  6465  					if shift >= 64 {
  6466  						return ErrIntOverflow
  6467  					}
  6468  					if iNdEx >= l {
  6469  						return io.ErrUnexpectedEOF
  6470  					}
  6471  					b := dAtA[iNdEx]
  6472  					iNdEx++
  6473  					wire |= uint64(b&0x7F) << shift
  6474  					if b < 0x80 {
  6475  						break
  6476  					}
  6477  				}
  6478  				fieldNum := int32(wire >> 3)
  6479  				if fieldNum == 1 {
  6480  					var stringLenmapkey uint64
  6481  					for shift := uint(0); ; shift += 7 {
  6482  						if shift >= 64 {
  6483  							return ErrIntOverflow
  6484  						}
  6485  						if iNdEx >= l {
  6486  							return io.ErrUnexpectedEOF
  6487  						}
  6488  						b := dAtA[iNdEx]
  6489  						iNdEx++
  6490  						stringLenmapkey |= uint64(b&0x7F) << shift
  6491  						if b < 0x80 {
  6492  							break
  6493  						}
  6494  					}
  6495  					intStringLenmapkey := int(stringLenmapkey)
  6496  					if intStringLenmapkey < 0 {
  6497  						return ErrInvalidLength
  6498  					}
  6499  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  6500  					if postStringIndexmapkey < 0 {
  6501  						return ErrInvalidLength
  6502  					}
  6503  					if postStringIndexmapkey > l {
  6504  						return io.ErrUnexpectedEOF
  6505  					}
  6506  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  6507  					iNdEx = postStringIndexmapkey
  6508  				} else if fieldNum == 2 {
  6509  					var mapmsglen int
  6510  					for shift := uint(0); ; shift += 7 {
  6511  						if shift >= 64 {
  6512  							return ErrIntOverflow
  6513  						}
  6514  						if iNdEx >= l {
  6515  							return io.ErrUnexpectedEOF
  6516  						}
  6517  						b := dAtA[iNdEx]
  6518  						iNdEx++
  6519  						mapmsglen |= int(b&0x7F) << shift
  6520  						if b < 0x80 {
  6521  							break
  6522  						}
  6523  					}
  6524  					if mapmsglen < 0 {
  6525  						return ErrInvalidLength
  6526  					}
  6527  					postmsgIndex := iNdEx + mapmsglen
  6528  					if postmsgIndex < 0 {
  6529  						return ErrInvalidLength
  6530  					}
  6531  					if postmsgIndex > l {
  6532  						return io.ErrUnexpectedEOF
  6533  					}
  6534  					mapvalue = &BindVariable{}
  6535  					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
  6536  						return err
  6537  					}
  6538  					iNdEx = postmsgIndex
  6539  				} else {
  6540  					iNdEx = entryPreIndex
  6541  					skippy, err := skip(dAtA[iNdEx:])
  6542  					if err != nil {
  6543  						return err
  6544  					}
  6545  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  6546  						return ErrInvalidLength
  6547  					}
  6548  					if (iNdEx + skippy) > postIndex {
  6549  						return io.ErrUnexpectedEOF
  6550  					}
  6551  					iNdEx += skippy
  6552  				}
  6553  			}
  6554  			m.BindVariables[mapkey] = mapvalue
  6555  			iNdEx = postIndex
  6556  		default:
  6557  			iNdEx = preIndex
  6558  			skippy, err := skip(dAtA[iNdEx:])
  6559  			if err != nil {
  6560  				return err
  6561  			}
  6562  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6563  				return ErrInvalidLength
  6564  			}
  6565  			if (iNdEx + skippy) > l {
  6566  				return io.ErrUnexpectedEOF
  6567  			}
  6568  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6569  			iNdEx += skippy
  6570  		}
  6571  	}
  6572  
  6573  	if iNdEx > l {
  6574  		return io.ErrUnexpectedEOF
  6575  	}
  6576  	return nil
  6577  }
  6578  func (m *ExecuteOptions) UnmarshalVT(dAtA []byte) error {
  6579  	l := len(dAtA)
  6580  	iNdEx := 0
  6581  	for iNdEx < l {
  6582  		preIndex := iNdEx
  6583  		var wire uint64
  6584  		for shift := uint(0); ; shift += 7 {
  6585  			if shift >= 64 {
  6586  				return ErrIntOverflow
  6587  			}
  6588  			if iNdEx >= l {
  6589  				return io.ErrUnexpectedEOF
  6590  			}
  6591  			b := dAtA[iNdEx]
  6592  			iNdEx++
  6593  			wire |= uint64(b&0x7F) << shift
  6594  			if b < 0x80 {
  6595  				break
  6596  			}
  6597  		}
  6598  		fieldNum := int32(wire >> 3)
  6599  		wireType := int(wire & 0x7)
  6600  		if wireType == 4 {
  6601  			return fmt.Errorf("proto: ExecuteOptions: wiretype end group for non-group")
  6602  		}
  6603  		if fieldNum <= 0 {
  6604  			return fmt.Errorf("proto: ExecuteOptions: illegal tag %d (wire type %d)", fieldNum, wire)
  6605  		}
  6606  		switch fieldNum {
  6607  		case 4:
  6608  			if wireType != 0 {
  6609  				return fmt.Errorf("proto: wrong wireType = %d for field IncludedFields", wireType)
  6610  			}
  6611  			m.IncludedFields = 0
  6612  			for shift := uint(0); ; shift += 7 {
  6613  				if shift >= 64 {
  6614  					return ErrIntOverflow
  6615  				}
  6616  				if iNdEx >= l {
  6617  					return io.ErrUnexpectedEOF
  6618  				}
  6619  				b := dAtA[iNdEx]
  6620  				iNdEx++
  6621  				m.IncludedFields |= ExecuteOptions_IncludedFields(b&0x7F) << shift
  6622  				if b < 0x80 {
  6623  					break
  6624  				}
  6625  			}
  6626  		case 5:
  6627  			if wireType != 0 {
  6628  				return fmt.Errorf("proto: wrong wireType = %d for field ClientFoundRows", wireType)
  6629  			}
  6630  			var v int
  6631  			for shift := uint(0); ; shift += 7 {
  6632  				if shift >= 64 {
  6633  					return ErrIntOverflow
  6634  				}
  6635  				if iNdEx >= l {
  6636  					return io.ErrUnexpectedEOF
  6637  				}
  6638  				b := dAtA[iNdEx]
  6639  				iNdEx++
  6640  				v |= int(b&0x7F) << shift
  6641  				if b < 0x80 {
  6642  					break
  6643  				}
  6644  			}
  6645  			m.ClientFoundRows = bool(v != 0)
  6646  		case 6:
  6647  			if wireType != 0 {
  6648  				return fmt.Errorf("proto: wrong wireType = %d for field Workload", wireType)
  6649  			}
  6650  			m.Workload = 0
  6651  			for shift := uint(0); ; shift += 7 {
  6652  				if shift >= 64 {
  6653  					return ErrIntOverflow
  6654  				}
  6655  				if iNdEx >= l {
  6656  					return io.ErrUnexpectedEOF
  6657  				}
  6658  				b := dAtA[iNdEx]
  6659  				iNdEx++
  6660  				m.Workload |= ExecuteOptions_Workload(b&0x7F) << shift
  6661  				if b < 0x80 {
  6662  					break
  6663  				}
  6664  			}
  6665  		case 8:
  6666  			if wireType != 0 {
  6667  				return fmt.Errorf("proto: wrong wireType = %d for field SqlSelectLimit", wireType)
  6668  			}
  6669  			m.SqlSelectLimit = 0
  6670  			for shift := uint(0); ; shift += 7 {
  6671  				if shift >= 64 {
  6672  					return ErrIntOverflow
  6673  				}
  6674  				if iNdEx >= l {
  6675  					return io.ErrUnexpectedEOF
  6676  				}
  6677  				b := dAtA[iNdEx]
  6678  				iNdEx++
  6679  				m.SqlSelectLimit |= int64(b&0x7F) << shift
  6680  				if b < 0x80 {
  6681  					break
  6682  				}
  6683  			}
  6684  		case 9:
  6685  			if wireType != 0 {
  6686  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionIsolation", wireType)
  6687  			}
  6688  			m.TransactionIsolation = 0
  6689  			for shift := uint(0); ; shift += 7 {
  6690  				if shift >= 64 {
  6691  					return ErrIntOverflow
  6692  				}
  6693  				if iNdEx >= l {
  6694  					return io.ErrUnexpectedEOF
  6695  				}
  6696  				b := dAtA[iNdEx]
  6697  				iNdEx++
  6698  				m.TransactionIsolation |= ExecuteOptions_TransactionIsolation(b&0x7F) << shift
  6699  				if b < 0x80 {
  6700  					break
  6701  				}
  6702  			}
  6703  		case 10:
  6704  			if wireType != 0 {
  6705  				return fmt.Errorf("proto: wrong wireType = %d for field SkipQueryPlanCache", wireType)
  6706  			}
  6707  			var v int
  6708  			for shift := uint(0); ; shift += 7 {
  6709  				if shift >= 64 {
  6710  					return ErrIntOverflow
  6711  				}
  6712  				if iNdEx >= l {
  6713  					return io.ErrUnexpectedEOF
  6714  				}
  6715  				b := dAtA[iNdEx]
  6716  				iNdEx++
  6717  				v |= int(b&0x7F) << shift
  6718  				if b < 0x80 {
  6719  					break
  6720  				}
  6721  			}
  6722  			m.SkipQueryPlanCache = bool(v != 0)
  6723  		case 11:
  6724  			if wireType != 0 {
  6725  				return fmt.Errorf("proto: wrong wireType = %d for field PlannerVersion", wireType)
  6726  			}
  6727  			m.PlannerVersion = 0
  6728  			for shift := uint(0); ; shift += 7 {
  6729  				if shift >= 64 {
  6730  					return ErrIntOverflow
  6731  				}
  6732  				if iNdEx >= l {
  6733  					return io.ErrUnexpectedEOF
  6734  				}
  6735  				b := dAtA[iNdEx]
  6736  				iNdEx++
  6737  				m.PlannerVersion |= ExecuteOptions_PlannerVersion(b&0x7F) << shift
  6738  				if b < 0x80 {
  6739  					break
  6740  				}
  6741  			}
  6742  		case 12:
  6743  			if wireType != 0 {
  6744  				return fmt.Errorf("proto: wrong wireType = %d for field HasCreatedTempTables", wireType)
  6745  			}
  6746  			var v int
  6747  			for shift := uint(0); ; shift += 7 {
  6748  				if shift >= 64 {
  6749  					return ErrIntOverflow
  6750  				}
  6751  				if iNdEx >= l {
  6752  					return io.ErrUnexpectedEOF
  6753  				}
  6754  				b := dAtA[iNdEx]
  6755  				iNdEx++
  6756  				v |= int(b&0x7F) << shift
  6757  				if b < 0x80 {
  6758  					break
  6759  				}
  6760  			}
  6761  			m.HasCreatedTempTables = bool(v != 0)
  6762  		default:
  6763  			iNdEx = preIndex
  6764  			skippy, err := skip(dAtA[iNdEx:])
  6765  			if err != nil {
  6766  				return err
  6767  			}
  6768  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6769  				return ErrInvalidLength
  6770  			}
  6771  			if (iNdEx + skippy) > l {
  6772  				return io.ErrUnexpectedEOF
  6773  			}
  6774  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6775  			iNdEx += skippy
  6776  		}
  6777  	}
  6778  
  6779  	if iNdEx > l {
  6780  		return io.ErrUnexpectedEOF
  6781  	}
  6782  	return nil
  6783  }
  6784  func (m *Field) UnmarshalVT(dAtA []byte) error {
  6785  	l := len(dAtA)
  6786  	iNdEx := 0
  6787  	for iNdEx < l {
  6788  		preIndex := iNdEx
  6789  		var wire uint64
  6790  		for shift := uint(0); ; shift += 7 {
  6791  			if shift >= 64 {
  6792  				return ErrIntOverflow
  6793  			}
  6794  			if iNdEx >= l {
  6795  				return io.ErrUnexpectedEOF
  6796  			}
  6797  			b := dAtA[iNdEx]
  6798  			iNdEx++
  6799  			wire |= uint64(b&0x7F) << shift
  6800  			if b < 0x80 {
  6801  				break
  6802  			}
  6803  		}
  6804  		fieldNum := int32(wire >> 3)
  6805  		wireType := int(wire & 0x7)
  6806  		if wireType == 4 {
  6807  			return fmt.Errorf("proto: Field: wiretype end group for non-group")
  6808  		}
  6809  		if fieldNum <= 0 {
  6810  			return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire)
  6811  		}
  6812  		switch fieldNum {
  6813  		case 1:
  6814  			if wireType != 2 {
  6815  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  6816  			}
  6817  			var stringLen uint64
  6818  			for shift := uint(0); ; shift += 7 {
  6819  				if shift >= 64 {
  6820  					return ErrIntOverflow
  6821  				}
  6822  				if iNdEx >= l {
  6823  					return io.ErrUnexpectedEOF
  6824  				}
  6825  				b := dAtA[iNdEx]
  6826  				iNdEx++
  6827  				stringLen |= uint64(b&0x7F) << shift
  6828  				if b < 0x80 {
  6829  					break
  6830  				}
  6831  			}
  6832  			intStringLen := int(stringLen)
  6833  			if intStringLen < 0 {
  6834  				return ErrInvalidLength
  6835  			}
  6836  			postIndex := iNdEx + intStringLen
  6837  			if postIndex < 0 {
  6838  				return ErrInvalidLength
  6839  			}
  6840  			if postIndex > l {
  6841  				return io.ErrUnexpectedEOF
  6842  			}
  6843  			m.Name = string(dAtA[iNdEx:postIndex])
  6844  			iNdEx = postIndex
  6845  		case 2:
  6846  			if wireType != 0 {
  6847  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  6848  			}
  6849  			m.Type = 0
  6850  			for shift := uint(0); ; shift += 7 {
  6851  				if shift >= 64 {
  6852  					return ErrIntOverflow
  6853  				}
  6854  				if iNdEx >= l {
  6855  					return io.ErrUnexpectedEOF
  6856  				}
  6857  				b := dAtA[iNdEx]
  6858  				iNdEx++
  6859  				m.Type |= Type(b&0x7F) << shift
  6860  				if b < 0x80 {
  6861  					break
  6862  				}
  6863  			}
  6864  		case 3:
  6865  			if wireType != 2 {
  6866  				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
  6867  			}
  6868  			var stringLen uint64
  6869  			for shift := uint(0); ; shift += 7 {
  6870  				if shift >= 64 {
  6871  					return ErrIntOverflow
  6872  				}
  6873  				if iNdEx >= l {
  6874  					return io.ErrUnexpectedEOF
  6875  				}
  6876  				b := dAtA[iNdEx]
  6877  				iNdEx++
  6878  				stringLen |= uint64(b&0x7F) << shift
  6879  				if b < 0x80 {
  6880  					break
  6881  				}
  6882  			}
  6883  			intStringLen := int(stringLen)
  6884  			if intStringLen < 0 {
  6885  				return ErrInvalidLength
  6886  			}
  6887  			postIndex := iNdEx + intStringLen
  6888  			if postIndex < 0 {
  6889  				return ErrInvalidLength
  6890  			}
  6891  			if postIndex > l {
  6892  				return io.ErrUnexpectedEOF
  6893  			}
  6894  			m.Table = string(dAtA[iNdEx:postIndex])
  6895  			iNdEx = postIndex
  6896  		case 4:
  6897  			if wireType != 2 {
  6898  				return fmt.Errorf("proto: wrong wireType = %d for field OrgTable", wireType)
  6899  			}
  6900  			var stringLen uint64
  6901  			for shift := uint(0); ; shift += 7 {
  6902  				if shift >= 64 {
  6903  					return ErrIntOverflow
  6904  				}
  6905  				if iNdEx >= l {
  6906  					return io.ErrUnexpectedEOF
  6907  				}
  6908  				b := dAtA[iNdEx]
  6909  				iNdEx++
  6910  				stringLen |= uint64(b&0x7F) << shift
  6911  				if b < 0x80 {
  6912  					break
  6913  				}
  6914  			}
  6915  			intStringLen := int(stringLen)
  6916  			if intStringLen < 0 {
  6917  				return ErrInvalidLength
  6918  			}
  6919  			postIndex := iNdEx + intStringLen
  6920  			if postIndex < 0 {
  6921  				return ErrInvalidLength
  6922  			}
  6923  			if postIndex > l {
  6924  				return io.ErrUnexpectedEOF
  6925  			}
  6926  			m.OrgTable = string(dAtA[iNdEx:postIndex])
  6927  			iNdEx = postIndex
  6928  		case 5:
  6929  			if wireType != 2 {
  6930  				return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType)
  6931  			}
  6932  			var stringLen uint64
  6933  			for shift := uint(0); ; shift += 7 {
  6934  				if shift >= 64 {
  6935  					return ErrIntOverflow
  6936  				}
  6937  				if iNdEx >= l {
  6938  					return io.ErrUnexpectedEOF
  6939  				}
  6940  				b := dAtA[iNdEx]
  6941  				iNdEx++
  6942  				stringLen |= uint64(b&0x7F) << shift
  6943  				if b < 0x80 {
  6944  					break
  6945  				}
  6946  			}
  6947  			intStringLen := int(stringLen)
  6948  			if intStringLen < 0 {
  6949  				return ErrInvalidLength
  6950  			}
  6951  			postIndex := iNdEx + intStringLen
  6952  			if postIndex < 0 {
  6953  				return ErrInvalidLength
  6954  			}
  6955  			if postIndex > l {
  6956  				return io.ErrUnexpectedEOF
  6957  			}
  6958  			m.Database = string(dAtA[iNdEx:postIndex])
  6959  			iNdEx = postIndex
  6960  		case 6:
  6961  			if wireType != 2 {
  6962  				return fmt.Errorf("proto: wrong wireType = %d for field OrgName", wireType)
  6963  			}
  6964  			var stringLen uint64
  6965  			for shift := uint(0); ; shift += 7 {
  6966  				if shift >= 64 {
  6967  					return ErrIntOverflow
  6968  				}
  6969  				if iNdEx >= l {
  6970  					return io.ErrUnexpectedEOF
  6971  				}
  6972  				b := dAtA[iNdEx]
  6973  				iNdEx++
  6974  				stringLen |= uint64(b&0x7F) << shift
  6975  				if b < 0x80 {
  6976  					break
  6977  				}
  6978  			}
  6979  			intStringLen := int(stringLen)
  6980  			if intStringLen < 0 {
  6981  				return ErrInvalidLength
  6982  			}
  6983  			postIndex := iNdEx + intStringLen
  6984  			if postIndex < 0 {
  6985  				return ErrInvalidLength
  6986  			}
  6987  			if postIndex > l {
  6988  				return io.ErrUnexpectedEOF
  6989  			}
  6990  			m.OrgName = string(dAtA[iNdEx:postIndex])
  6991  			iNdEx = postIndex
  6992  		case 7:
  6993  			if wireType != 0 {
  6994  				return fmt.Errorf("proto: wrong wireType = %d for field ColumnLength", wireType)
  6995  			}
  6996  			m.ColumnLength = 0
  6997  			for shift := uint(0); ; shift += 7 {
  6998  				if shift >= 64 {
  6999  					return ErrIntOverflow
  7000  				}
  7001  				if iNdEx >= l {
  7002  					return io.ErrUnexpectedEOF
  7003  				}
  7004  				b := dAtA[iNdEx]
  7005  				iNdEx++
  7006  				m.ColumnLength |= uint32(b&0x7F) << shift
  7007  				if b < 0x80 {
  7008  					break
  7009  				}
  7010  			}
  7011  		case 8:
  7012  			if wireType != 0 {
  7013  				return fmt.Errorf("proto: wrong wireType = %d for field Charset", wireType)
  7014  			}
  7015  			m.Charset = 0
  7016  			for shift := uint(0); ; shift += 7 {
  7017  				if shift >= 64 {
  7018  					return ErrIntOverflow
  7019  				}
  7020  				if iNdEx >= l {
  7021  					return io.ErrUnexpectedEOF
  7022  				}
  7023  				b := dAtA[iNdEx]
  7024  				iNdEx++
  7025  				m.Charset |= uint32(b&0x7F) << shift
  7026  				if b < 0x80 {
  7027  					break
  7028  				}
  7029  			}
  7030  		case 9:
  7031  			if wireType != 0 {
  7032  				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
  7033  			}
  7034  			m.Decimals = 0
  7035  			for shift := uint(0); ; shift += 7 {
  7036  				if shift >= 64 {
  7037  					return ErrIntOverflow
  7038  				}
  7039  				if iNdEx >= l {
  7040  					return io.ErrUnexpectedEOF
  7041  				}
  7042  				b := dAtA[iNdEx]
  7043  				iNdEx++
  7044  				m.Decimals |= uint32(b&0x7F) << shift
  7045  				if b < 0x80 {
  7046  					break
  7047  				}
  7048  			}
  7049  		case 10:
  7050  			if wireType != 0 {
  7051  				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
  7052  			}
  7053  			m.Flags = 0
  7054  			for shift := uint(0); ; shift += 7 {
  7055  				if shift >= 64 {
  7056  					return ErrIntOverflow
  7057  				}
  7058  				if iNdEx >= l {
  7059  					return io.ErrUnexpectedEOF
  7060  				}
  7061  				b := dAtA[iNdEx]
  7062  				iNdEx++
  7063  				m.Flags |= uint32(b&0x7F) << shift
  7064  				if b < 0x80 {
  7065  					break
  7066  				}
  7067  			}
  7068  		case 11:
  7069  			if wireType != 2 {
  7070  				return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType)
  7071  			}
  7072  			var stringLen uint64
  7073  			for shift := uint(0); ; shift += 7 {
  7074  				if shift >= 64 {
  7075  					return ErrIntOverflow
  7076  				}
  7077  				if iNdEx >= l {
  7078  					return io.ErrUnexpectedEOF
  7079  				}
  7080  				b := dAtA[iNdEx]
  7081  				iNdEx++
  7082  				stringLen |= uint64(b&0x7F) << shift
  7083  				if b < 0x80 {
  7084  					break
  7085  				}
  7086  			}
  7087  			intStringLen := int(stringLen)
  7088  			if intStringLen < 0 {
  7089  				return ErrInvalidLength
  7090  			}
  7091  			postIndex := iNdEx + intStringLen
  7092  			if postIndex < 0 {
  7093  				return ErrInvalidLength
  7094  			}
  7095  			if postIndex > l {
  7096  				return io.ErrUnexpectedEOF
  7097  			}
  7098  			m.ColumnType = string(dAtA[iNdEx:postIndex])
  7099  			iNdEx = postIndex
  7100  		default:
  7101  			iNdEx = preIndex
  7102  			skippy, err := skip(dAtA[iNdEx:])
  7103  			if err != nil {
  7104  				return err
  7105  			}
  7106  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7107  				return ErrInvalidLength
  7108  			}
  7109  			if (iNdEx + skippy) > l {
  7110  				return io.ErrUnexpectedEOF
  7111  			}
  7112  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7113  			iNdEx += skippy
  7114  		}
  7115  	}
  7116  
  7117  	if iNdEx > l {
  7118  		return io.ErrUnexpectedEOF
  7119  	}
  7120  	return nil
  7121  }
  7122  func (m *Row) UnmarshalVT(dAtA []byte) error {
  7123  	l := len(dAtA)
  7124  	iNdEx := 0
  7125  	for iNdEx < l {
  7126  		preIndex := iNdEx
  7127  		var wire uint64
  7128  		for shift := uint(0); ; shift += 7 {
  7129  			if shift >= 64 {
  7130  				return ErrIntOverflow
  7131  			}
  7132  			if iNdEx >= l {
  7133  				return io.ErrUnexpectedEOF
  7134  			}
  7135  			b := dAtA[iNdEx]
  7136  			iNdEx++
  7137  			wire |= uint64(b&0x7F) << shift
  7138  			if b < 0x80 {
  7139  				break
  7140  			}
  7141  		}
  7142  		fieldNum := int32(wire >> 3)
  7143  		wireType := int(wire & 0x7)
  7144  		if wireType == 4 {
  7145  			return fmt.Errorf("proto: Row: wiretype end group for non-group")
  7146  		}
  7147  		if fieldNum <= 0 {
  7148  			return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire)
  7149  		}
  7150  		switch fieldNum {
  7151  		case 1:
  7152  			if wireType == 0 {
  7153  				var v uint64
  7154  				for shift := uint(0); ; shift += 7 {
  7155  					if shift >= 64 {
  7156  						return ErrIntOverflow
  7157  					}
  7158  					if iNdEx >= l {
  7159  						return io.ErrUnexpectedEOF
  7160  					}
  7161  					b := dAtA[iNdEx]
  7162  					iNdEx++
  7163  					v |= uint64(b&0x7F) << shift
  7164  					if b < 0x80 {
  7165  						break
  7166  					}
  7167  				}
  7168  				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
  7169  				m.Lengths = append(m.Lengths, int64(v))
  7170  			} else if wireType == 2 {
  7171  				var packedLen int
  7172  				for shift := uint(0); ; shift += 7 {
  7173  					if shift >= 64 {
  7174  						return ErrIntOverflow
  7175  					}
  7176  					if iNdEx >= l {
  7177  						return io.ErrUnexpectedEOF
  7178  					}
  7179  					b := dAtA[iNdEx]
  7180  					iNdEx++
  7181  					packedLen |= int(b&0x7F) << shift
  7182  					if b < 0x80 {
  7183  						break
  7184  					}
  7185  				}
  7186  				if packedLen < 0 {
  7187  					return ErrInvalidLength
  7188  				}
  7189  				postIndex := iNdEx + packedLen
  7190  				if postIndex < 0 {
  7191  					return ErrInvalidLength
  7192  				}
  7193  				if postIndex > l {
  7194  					return io.ErrUnexpectedEOF
  7195  				}
  7196  				var elementCount int
  7197  				var count int
  7198  				for _, integer := range dAtA[iNdEx:postIndex] {
  7199  					if integer < 128 {
  7200  						count++
  7201  					}
  7202  				}
  7203  				elementCount = count
  7204  				if elementCount != 0 && len(m.Lengths) == 0 && cap(m.Lengths) < elementCount {
  7205  					m.Lengths = make([]int64, 0, elementCount)
  7206  				}
  7207  				for iNdEx < postIndex {
  7208  					var v uint64
  7209  					for shift := uint(0); ; shift += 7 {
  7210  						if shift >= 64 {
  7211  							return ErrIntOverflow
  7212  						}
  7213  						if iNdEx >= l {
  7214  							return io.ErrUnexpectedEOF
  7215  						}
  7216  						b := dAtA[iNdEx]
  7217  						iNdEx++
  7218  						v |= uint64(b&0x7F) << shift
  7219  						if b < 0x80 {
  7220  							break
  7221  						}
  7222  					}
  7223  					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
  7224  					m.Lengths = append(m.Lengths, int64(v))
  7225  				}
  7226  			} else {
  7227  				return fmt.Errorf("proto: wrong wireType = %d for field Lengths", wireType)
  7228  			}
  7229  		case 2:
  7230  			if wireType != 2 {
  7231  				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
  7232  			}
  7233  			var byteLen int
  7234  			for shift := uint(0); ; shift += 7 {
  7235  				if shift >= 64 {
  7236  					return ErrIntOverflow
  7237  				}
  7238  				if iNdEx >= l {
  7239  					return io.ErrUnexpectedEOF
  7240  				}
  7241  				b := dAtA[iNdEx]
  7242  				iNdEx++
  7243  				byteLen |= int(b&0x7F) << shift
  7244  				if b < 0x80 {
  7245  					break
  7246  				}
  7247  			}
  7248  			if byteLen < 0 {
  7249  				return ErrInvalidLength
  7250  			}
  7251  			postIndex := iNdEx + byteLen
  7252  			if postIndex < 0 {
  7253  				return ErrInvalidLength
  7254  			}
  7255  			if postIndex > l {
  7256  				return io.ErrUnexpectedEOF
  7257  			}
  7258  			m.Values = append(m.Values[:0], dAtA[iNdEx:postIndex]...)
  7259  			if m.Values == nil {
  7260  				m.Values = []byte{}
  7261  			}
  7262  			iNdEx = postIndex
  7263  		default:
  7264  			iNdEx = preIndex
  7265  			skippy, err := skip(dAtA[iNdEx:])
  7266  			if err != nil {
  7267  				return err
  7268  			}
  7269  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7270  				return ErrInvalidLength
  7271  			}
  7272  			if (iNdEx + skippy) > l {
  7273  				return io.ErrUnexpectedEOF
  7274  			}
  7275  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7276  			iNdEx += skippy
  7277  		}
  7278  	}
  7279  
  7280  	if iNdEx > l {
  7281  		return io.ErrUnexpectedEOF
  7282  	}
  7283  	return nil
  7284  }
  7285  func (m *QueryResult) UnmarshalVT(dAtA []byte) error {
  7286  	l := len(dAtA)
  7287  	iNdEx := 0
  7288  	for iNdEx < l {
  7289  		preIndex := iNdEx
  7290  		var wire uint64
  7291  		for shift := uint(0); ; shift += 7 {
  7292  			if shift >= 64 {
  7293  				return ErrIntOverflow
  7294  			}
  7295  			if iNdEx >= l {
  7296  				return io.ErrUnexpectedEOF
  7297  			}
  7298  			b := dAtA[iNdEx]
  7299  			iNdEx++
  7300  			wire |= uint64(b&0x7F) << shift
  7301  			if b < 0x80 {
  7302  				break
  7303  			}
  7304  		}
  7305  		fieldNum := int32(wire >> 3)
  7306  		wireType := int(wire & 0x7)
  7307  		if wireType == 4 {
  7308  			return fmt.Errorf("proto: QueryResult: wiretype end group for non-group")
  7309  		}
  7310  		if fieldNum <= 0 {
  7311  			return fmt.Errorf("proto: QueryResult: illegal tag %d (wire type %d)", fieldNum, wire)
  7312  		}
  7313  		switch fieldNum {
  7314  		case 1:
  7315  			if wireType != 2 {
  7316  				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
  7317  			}
  7318  			var msglen int
  7319  			for shift := uint(0); ; shift += 7 {
  7320  				if shift >= 64 {
  7321  					return ErrIntOverflow
  7322  				}
  7323  				if iNdEx >= l {
  7324  					return io.ErrUnexpectedEOF
  7325  				}
  7326  				b := dAtA[iNdEx]
  7327  				iNdEx++
  7328  				msglen |= int(b&0x7F) << shift
  7329  				if b < 0x80 {
  7330  					break
  7331  				}
  7332  			}
  7333  			if msglen < 0 {
  7334  				return ErrInvalidLength
  7335  			}
  7336  			postIndex := iNdEx + msglen
  7337  			if postIndex < 0 {
  7338  				return ErrInvalidLength
  7339  			}
  7340  			if postIndex > l {
  7341  				return io.ErrUnexpectedEOF
  7342  			}
  7343  			m.Fields = append(m.Fields, &Field{})
  7344  			if err := m.Fields[len(m.Fields)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7345  				return err
  7346  			}
  7347  			iNdEx = postIndex
  7348  		case 2:
  7349  			if wireType != 0 {
  7350  				return fmt.Errorf("proto: wrong wireType = %d for field RowsAffected", wireType)
  7351  			}
  7352  			m.RowsAffected = 0
  7353  			for shift := uint(0); ; shift += 7 {
  7354  				if shift >= 64 {
  7355  					return ErrIntOverflow
  7356  				}
  7357  				if iNdEx >= l {
  7358  					return io.ErrUnexpectedEOF
  7359  				}
  7360  				b := dAtA[iNdEx]
  7361  				iNdEx++
  7362  				m.RowsAffected |= uint64(b&0x7F) << shift
  7363  				if b < 0x80 {
  7364  					break
  7365  				}
  7366  			}
  7367  		case 3:
  7368  			if wireType != 0 {
  7369  				return fmt.Errorf("proto: wrong wireType = %d for field InsertId", wireType)
  7370  			}
  7371  			m.InsertId = 0
  7372  			for shift := uint(0); ; shift += 7 {
  7373  				if shift >= 64 {
  7374  					return ErrIntOverflow
  7375  				}
  7376  				if iNdEx >= l {
  7377  					return io.ErrUnexpectedEOF
  7378  				}
  7379  				b := dAtA[iNdEx]
  7380  				iNdEx++
  7381  				m.InsertId |= uint64(b&0x7F) << shift
  7382  				if b < 0x80 {
  7383  					break
  7384  				}
  7385  			}
  7386  		case 4:
  7387  			if wireType != 2 {
  7388  				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
  7389  			}
  7390  			var msglen int
  7391  			for shift := uint(0); ; shift += 7 {
  7392  				if shift >= 64 {
  7393  					return ErrIntOverflow
  7394  				}
  7395  				if iNdEx >= l {
  7396  					return io.ErrUnexpectedEOF
  7397  				}
  7398  				b := dAtA[iNdEx]
  7399  				iNdEx++
  7400  				msglen |= int(b&0x7F) << shift
  7401  				if b < 0x80 {
  7402  					break
  7403  				}
  7404  			}
  7405  			if msglen < 0 {
  7406  				return ErrInvalidLength
  7407  			}
  7408  			postIndex := iNdEx + msglen
  7409  			if postIndex < 0 {
  7410  				return ErrInvalidLength
  7411  			}
  7412  			if postIndex > l {
  7413  				return io.ErrUnexpectedEOF
  7414  			}
  7415  			m.Rows = append(m.Rows, &Row{})
  7416  			if err := m.Rows[len(m.Rows)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7417  				return err
  7418  			}
  7419  			iNdEx = postIndex
  7420  		default:
  7421  			iNdEx = preIndex
  7422  			skippy, err := skip(dAtA[iNdEx:])
  7423  			if err != nil {
  7424  				return err
  7425  			}
  7426  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7427  				return ErrInvalidLength
  7428  			}
  7429  			if (iNdEx + skippy) > l {
  7430  				return io.ErrUnexpectedEOF
  7431  			}
  7432  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7433  			iNdEx += skippy
  7434  		}
  7435  	}
  7436  
  7437  	if iNdEx > l {
  7438  		return io.ErrUnexpectedEOF
  7439  	}
  7440  	return nil
  7441  }
  7442  func (m *QueryWarning) UnmarshalVT(dAtA []byte) error {
  7443  	l := len(dAtA)
  7444  	iNdEx := 0
  7445  	for iNdEx < l {
  7446  		preIndex := iNdEx
  7447  		var wire uint64
  7448  		for shift := uint(0); ; shift += 7 {
  7449  			if shift >= 64 {
  7450  				return ErrIntOverflow
  7451  			}
  7452  			if iNdEx >= l {
  7453  				return io.ErrUnexpectedEOF
  7454  			}
  7455  			b := dAtA[iNdEx]
  7456  			iNdEx++
  7457  			wire |= uint64(b&0x7F) << shift
  7458  			if b < 0x80 {
  7459  				break
  7460  			}
  7461  		}
  7462  		fieldNum := int32(wire >> 3)
  7463  		wireType := int(wire & 0x7)
  7464  		if wireType == 4 {
  7465  			return fmt.Errorf("proto: QueryWarning: wiretype end group for non-group")
  7466  		}
  7467  		if fieldNum <= 0 {
  7468  			return fmt.Errorf("proto: QueryWarning: illegal tag %d (wire type %d)", fieldNum, wire)
  7469  		}
  7470  		switch fieldNum {
  7471  		case 1:
  7472  			if wireType != 0 {
  7473  				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
  7474  			}
  7475  			m.Code = 0
  7476  			for shift := uint(0); ; shift += 7 {
  7477  				if shift >= 64 {
  7478  					return ErrIntOverflow
  7479  				}
  7480  				if iNdEx >= l {
  7481  					return io.ErrUnexpectedEOF
  7482  				}
  7483  				b := dAtA[iNdEx]
  7484  				iNdEx++
  7485  				m.Code |= uint32(b&0x7F) << shift
  7486  				if b < 0x80 {
  7487  					break
  7488  				}
  7489  			}
  7490  		case 2:
  7491  			if wireType != 2 {
  7492  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  7493  			}
  7494  			var stringLen uint64
  7495  			for shift := uint(0); ; shift += 7 {
  7496  				if shift >= 64 {
  7497  					return ErrIntOverflow
  7498  				}
  7499  				if iNdEx >= l {
  7500  					return io.ErrUnexpectedEOF
  7501  				}
  7502  				b := dAtA[iNdEx]
  7503  				iNdEx++
  7504  				stringLen |= uint64(b&0x7F) << shift
  7505  				if b < 0x80 {
  7506  					break
  7507  				}
  7508  			}
  7509  			intStringLen := int(stringLen)
  7510  			if intStringLen < 0 {
  7511  				return ErrInvalidLength
  7512  			}
  7513  			postIndex := iNdEx + intStringLen
  7514  			if postIndex < 0 {
  7515  				return ErrInvalidLength
  7516  			}
  7517  			if postIndex > l {
  7518  				return io.ErrUnexpectedEOF
  7519  			}
  7520  			m.Message = string(dAtA[iNdEx:postIndex])
  7521  			iNdEx = postIndex
  7522  		default:
  7523  			iNdEx = preIndex
  7524  			skippy, err := skip(dAtA[iNdEx:])
  7525  			if err != nil {
  7526  				return err
  7527  			}
  7528  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7529  				return ErrInvalidLength
  7530  			}
  7531  			if (iNdEx + skippy) > l {
  7532  				return io.ErrUnexpectedEOF
  7533  			}
  7534  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7535  			iNdEx += skippy
  7536  		}
  7537  	}
  7538  
  7539  	if iNdEx > l {
  7540  		return io.ErrUnexpectedEOF
  7541  	}
  7542  	return nil
  7543  }
  7544  func (m *StreamEvent_Statement) UnmarshalVT(dAtA []byte) error {
  7545  	l := len(dAtA)
  7546  	iNdEx := 0
  7547  	for iNdEx < l {
  7548  		preIndex := iNdEx
  7549  		var wire uint64
  7550  		for shift := uint(0); ; shift += 7 {
  7551  			if shift >= 64 {
  7552  				return ErrIntOverflow
  7553  			}
  7554  			if iNdEx >= l {
  7555  				return io.ErrUnexpectedEOF
  7556  			}
  7557  			b := dAtA[iNdEx]
  7558  			iNdEx++
  7559  			wire |= uint64(b&0x7F) << shift
  7560  			if b < 0x80 {
  7561  				break
  7562  			}
  7563  		}
  7564  		fieldNum := int32(wire >> 3)
  7565  		wireType := int(wire & 0x7)
  7566  		if wireType == 4 {
  7567  			return fmt.Errorf("proto: StreamEvent_Statement: wiretype end group for non-group")
  7568  		}
  7569  		if fieldNum <= 0 {
  7570  			return fmt.Errorf("proto: StreamEvent_Statement: illegal tag %d (wire type %d)", fieldNum, wire)
  7571  		}
  7572  		switch fieldNum {
  7573  		case 1:
  7574  			if wireType != 0 {
  7575  				return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
  7576  			}
  7577  			m.Category = 0
  7578  			for shift := uint(0); ; shift += 7 {
  7579  				if shift >= 64 {
  7580  					return ErrIntOverflow
  7581  				}
  7582  				if iNdEx >= l {
  7583  					return io.ErrUnexpectedEOF
  7584  				}
  7585  				b := dAtA[iNdEx]
  7586  				iNdEx++
  7587  				m.Category |= StreamEvent_Statement_Category(b&0x7F) << shift
  7588  				if b < 0x80 {
  7589  					break
  7590  				}
  7591  			}
  7592  		case 2:
  7593  			if wireType != 2 {
  7594  				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
  7595  			}
  7596  			var stringLen uint64
  7597  			for shift := uint(0); ; shift += 7 {
  7598  				if shift >= 64 {
  7599  					return ErrIntOverflow
  7600  				}
  7601  				if iNdEx >= l {
  7602  					return io.ErrUnexpectedEOF
  7603  				}
  7604  				b := dAtA[iNdEx]
  7605  				iNdEx++
  7606  				stringLen |= uint64(b&0x7F) << shift
  7607  				if b < 0x80 {
  7608  					break
  7609  				}
  7610  			}
  7611  			intStringLen := int(stringLen)
  7612  			if intStringLen < 0 {
  7613  				return ErrInvalidLength
  7614  			}
  7615  			postIndex := iNdEx + intStringLen
  7616  			if postIndex < 0 {
  7617  				return ErrInvalidLength
  7618  			}
  7619  			if postIndex > l {
  7620  				return io.ErrUnexpectedEOF
  7621  			}
  7622  			m.TableName = string(dAtA[iNdEx:postIndex])
  7623  			iNdEx = postIndex
  7624  		case 3:
  7625  			if wireType != 2 {
  7626  				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKeyFields", wireType)
  7627  			}
  7628  			var msglen int
  7629  			for shift := uint(0); ; shift += 7 {
  7630  				if shift >= 64 {
  7631  					return ErrIntOverflow
  7632  				}
  7633  				if iNdEx >= l {
  7634  					return io.ErrUnexpectedEOF
  7635  				}
  7636  				b := dAtA[iNdEx]
  7637  				iNdEx++
  7638  				msglen |= int(b&0x7F) << shift
  7639  				if b < 0x80 {
  7640  					break
  7641  				}
  7642  			}
  7643  			if msglen < 0 {
  7644  				return ErrInvalidLength
  7645  			}
  7646  			postIndex := iNdEx + msglen
  7647  			if postIndex < 0 {
  7648  				return ErrInvalidLength
  7649  			}
  7650  			if postIndex > l {
  7651  				return io.ErrUnexpectedEOF
  7652  			}
  7653  			m.PrimaryKeyFields = append(m.PrimaryKeyFields, &Field{})
  7654  			if err := m.PrimaryKeyFields[len(m.PrimaryKeyFields)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7655  				return err
  7656  			}
  7657  			iNdEx = postIndex
  7658  		case 4:
  7659  			if wireType != 2 {
  7660  				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKeyValues", wireType)
  7661  			}
  7662  			var msglen int
  7663  			for shift := uint(0); ; shift += 7 {
  7664  				if shift >= 64 {
  7665  					return ErrIntOverflow
  7666  				}
  7667  				if iNdEx >= l {
  7668  					return io.ErrUnexpectedEOF
  7669  				}
  7670  				b := dAtA[iNdEx]
  7671  				iNdEx++
  7672  				msglen |= int(b&0x7F) << shift
  7673  				if b < 0x80 {
  7674  					break
  7675  				}
  7676  			}
  7677  			if msglen < 0 {
  7678  				return ErrInvalidLength
  7679  			}
  7680  			postIndex := iNdEx + msglen
  7681  			if postIndex < 0 {
  7682  				return ErrInvalidLength
  7683  			}
  7684  			if postIndex > l {
  7685  				return io.ErrUnexpectedEOF
  7686  			}
  7687  			m.PrimaryKeyValues = append(m.PrimaryKeyValues, &Row{})
  7688  			if err := m.PrimaryKeyValues[len(m.PrimaryKeyValues)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7689  				return err
  7690  			}
  7691  			iNdEx = postIndex
  7692  		case 5:
  7693  			if wireType != 2 {
  7694  				return fmt.Errorf("proto: wrong wireType = %d for field Sql", wireType)
  7695  			}
  7696  			var byteLen int
  7697  			for shift := uint(0); ; shift += 7 {
  7698  				if shift >= 64 {
  7699  					return ErrIntOverflow
  7700  				}
  7701  				if iNdEx >= l {
  7702  					return io.ErrUnexpectedEOF
  7703  				}
  7704  				b := dAtA[iNdEx]
  7705  				iNdEx++
  7706  				byteLen |= int(b&0x7F) << shift
  7707  				if b < 0x80 {
  7708  					break
  7709  				}
  7710  			}
  7711  			if byteLen < 0 {
  7712  				return ErrInvalidLength
  7713  			}
  7714  			postIndex := iNdEx + byteLen
  7715  			if postIndex < 0 {
  7716  				return ErrInvalidLength
  7717  			}
  7718  			if postIndex > l {
  7719  				return io.ErrUnexpectedEOF
  7720  			}
  7721  			m.Sql = append(m.Sql[:0], dAtA[iNdEx:postIndex]...)
  7722  			if m.Sql == nil {
  7723  				m.Sql = []byte{}
  7724  			}
  7725  			iNdEx = postIndex
  7726  		default:
  7727  			iNdEx = preIndex
  7728  			skippy, err := skip(dAtA[iNdEx:])
  7729  			if err != nil {
  7730  				return err
  7731  			}
  7732  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7733  				return ErrInvalidLength
  7734  			}
  7735  			if (iNdEx + skippy) > l {
  7736  				return io.ErrUnexpectedEOF
  7737  			}
  7738  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7739  			iNdEx += skippy
  7740  		}
  7741  	}
  7742  
  7743  	if iNdEx > l {
  7744  		return io.ErrUnexpectedEOF
  7745  	}
  7746  	return nil
  7747  }
  7748  func (m *StreamEvent) UnmarshalVT(dAtA []byte) error {
  7749  	l := len(dAtA)
  7750  	iNdEx := 0
  7751  	for iNdEx < l {
  7752  		preIndex := iNdEx
  7753  		var wire uint64
  7754  		for shift := uint(0); ; shift += 7 {
  7755  			if shift >= 64 {
  7756  				return ErrIntOverflow
  7757  			}
  7758  			if iNdEx >= l {
  7759  				return io.ErrUnexpectedEOF
  7760  			}
  7761  			b := dAtA[iNdEx]
  7762  			iNdEx++
  7763  			wire |= uint64(b&0x7F) << shift
  7764  			if b < 0x80 {
  7765  				break
  7766  			}
  7767  		}
  7768  		fieldNum := int32(wire >> 3)
  7769  		wireType := int(wire & 0x7)
  7770  		if wireType == 4 {
  7771  			return fmt.Errorf("proto: StreamEvent: wiretype end group for non-group")
  7772  		}
  7773  		if fieldNum <= 0 {
  7774  			return fmt.Errorf("proto: StreamEvent: illegal tag %d (wire type %d)", fieldNum, wire)
  7775  		}
  7776  		switch fieldNum {
  7777  		case 1:
  7778  			if wireType != 2 {
  7779  				return fmt.Errorf("proto: wrong wireType = %d for field Statements", wireType)
  7780  			}
  7781  			var msglen int
  7782  			for shift := uint(0); ; shift += 7 {
  7783  				if shift >= 64 {
  7784  					return ErrIntOverflow
  7785  				}
  7786  				if iNdEx >= l {
  7787  					return io.ErrUnexpectedEOF
  7788  				}
  7789  				b := dAtA[iNdEx]
  7790  				iNdEx++
  7791  				msglen |= int(b&0x7F) << shift
  7792  				if b < 0x80 {
  7793  					break
  7794  				}
  7795  			}
  7796  			if msglen < 0 {
  7797  				return ErrInvalidLength
  7798  			}
  7799  			postIndex := iNdEx + msglen
  7800  			if postIndex < 0 {
  7801  				return ErrInvalidLength
  7802  			}
  7803  			if postIndex > l {
  7804  				return io.ErrUnexpectedEOF
  7805  			}
  7806  			m.Statements = append(m.Statements, &StreamEvent_Statement{})
  7807  			if err := m.Statements[len(m.Statements)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7808  				return err
  7809  			}
  7810  			iNdEx = postIndex
  7811  		case 2:
  7812  			if wireType != 2 {
  7813  				return fmt.Errorf("proto: wrong wireType = %d for field EventToken", wireType)
  7814  			}
  7815  			var msglen int
  7816  			for shift := uint(0); ; shift += 7 {
  7817  				if shift >= 64 {
  7818  					return ErrIntOverflow
  7819  				}
  7820  				if iNdEx >= l {
  7821  					return io.ErrUnexpectedEOF
  7822  				}
  7823  				b := dAtA[iNdEx]
  7824  				iNdEx++
  7825  				msglen |= int(b&0x7F) << shift
  7826  				if b < 0x80 {
  7827  					break
  7828  				}
  7829  			}
  7830  			if msglen < 0 {
  7831  				return ErrInvalidLength
  7832  			}
  7833  			postIndex := iNdEx + msglen
  7834  			if postIndex < 0 {
  7835  				return ErrInvalidLength
  7836  			}
  7837  			if postIndex > l {
  7838  				return io.ErrUnexpectedEOF
  7839  			}
  7840  			if m.EventToken == nil {
  7841  				m.EventToken = &EventToken{}
  7842  			}
  7843  			if err := m.EventToken.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7844  				return err
  7845  			}
  7846  			iNdEx = postIndex
  7847  		default:
  7848  			iNdEx = preIndex
  7849  			skippy, err := skip(dAtA[iNdEx:])
  7850  			if err != nil {
  7851  				return err
  7852  			}
  7853  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7854  				return ErrInvalidLength
  7855  			}
  7856  			if (iNdEx + skippy) > l {
  7857  				return io.ErrUnexpectedEOF
  7858  			}
  7859  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7860  			iNdEx += skippy
  7861  		}
  7862  	}
  7863  
  7864  	if iNdEx > l {
  7865  		return io.ErrUnexpectedEOF
  7866  	}
  7867  	return nil
  7868  }
  7869  func (m *ExecuteRequest) UnmarshalVT(dAtA []byte) error {
  7870  	l := len(dAtA)
  7871  	iNdEx := 0
  7872  	for iNdEx < l {
  7873  		preIndex := iNdEx
  7874  		var wire uint64
  7875  		for shift := uint(0); ; shift += 7 {
  7876  			if shift >= 64 {
  7877  				return ErrIntOverflow
  7878  			}
  7879  			if iNdEx >= l {
  7880  				return io.ErrUnexpectedEOF
  7881  			}
  7882  			b := dAtA[iNdEx]
  7883  			iNdEx++
  7884  			wire |= uint64(b&0x7F) << shift
  7885  			if b < 0x80 {
  7886  				break
  7887  			}
  7888  		}
  7889  		fieldNum := int32(wire >> 3)
  7890  		wireType := int(wire & 0x7)
  7891  		if wireType == 4 {
  7892  			return fmt.Errorf("proto: ExecuteRequest: wiretype end group for non-group")
  7893  		}
  7894  		if fieldNum <= 0 {
  7895  			return fmt.Errorf("proto: ExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  7896  		}
  7897  		switch fieldNum {
  7898  		case 1:
  7899  			if wireType != 2 {
  7900  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  7901  			}
  7902  			var msglen int
  7903  			for shift := uint(0); ; shift += 7 {
  7904  				if shift >= 64 {
  7905  					return ErrIntOverflow
  7906  				}
  7907  				if iNdEx >= l {
  7908  					return io.ErrUnexpectedEOF
  7909  				}
  7910  				b := dAtA[iNdEx]
  7911  				iNdEx++
  7912  				msglen |= int(b&0x7F) << shift
  7913  				if b < 0x80 {
  7914  					break
  7915  				}
  7916  			}
  7917  			if msglen < 0 {
  7918  				return ErrInvalidLength
  7919  			}
  7920  			postIndex := iNdEx + msglen
  7921  			if postIndex < 0 {
  7922  				return ErrInvalidLength
  7923  			}
  7924  			if postIndex > l {
  7925  				return io.ErrUnexpectedEOF
  7926  			}
  7927  			if m.EffectiveCallerId == nil {
  7928  				m.EffectiveCallerId = &vtrpc.CallerID{}
  7929  			}
  7930  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7931  				return err
  7932  			}
  7933  			iNdEx = postIndex
  7934  		case 2:
  7935  			if wireType != 2 {
  7936  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  7937  			}
  7938  			var msglen int
  7939  			for shift := uint(0); ; shift += 7 {
  7940  				if shift >= 64 {
  7941  					return ErrIntOverflow
  7942  				}
  7943  				if iNdEx >= l {
  7944  					return io.ErrUnexpectedEOF
  7945  				}
  7946  				b := dAtA[iNdEx]
  7947  				iNdEx++
  7948  				msglen |= int(b&0x7F) << shift
  7949  				if b < 0x80 {
  7950  					break
  7951  				}
  7952  			}
  7953  			if msglen < 0 {
  7954  				return ErrInvalidLength
  7955  			}
  7956  			postIndex := iNdEx + msglen
  7957  			if postIndex < 0 {
  7958  				return ErrInvalidLength
  7959  			}
  7960  			if postIndex > l {
  7961  				return io.ErrUnexpectedEOF
  7962  			}
  7963  			if m.ImmediateCallerId == nil {
  7964  				m.ImmediateCallerId = &VTGateCallerID{}
  7965  			}
  7966  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7967  				return err
  7968  			}
  7969  			iNdEx = postIndex
  7970  		case 3:
  7971  			if wireType != 2 {
  7972  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  7973  			}
  7974  			var msglen int
  7975  			for shift := uint(0); ; shift += 7 {
  7976  				if shift >= 64 {
  7977  					return ErrIntOverflow
  7978  				}
  7979  				if iNdEx >= l {
  7980  					return io.ErrUnexpectedEOF
  7981  				}
  7982  				b := dAtA[iNdEx]
  7983  				iNdEx++
  7984  				msglen |= int(b&0x7F) << shift
  7985  				if b < 0x80 {
  7986  					break
  7987  				}
  7988  			}
  7989  			if msglen < 0 {
  7990  				return ErrInvalidLength
  7991  			}
  7992  			postIndex := iNdEx + msglen
  7993  			if postIndex < 0 {
  7994  				return ErrInvalidLength
  7995  			}
  7996  			if postIndex > l {
  7997  				return io.ErrUnexpectedEOF
  7998  			}
  7999  			if m.Target == nil {
  8000  				m.Target = &Target{}
  8001  			}
  8002  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8003  				return err
  8004  			}
  8005  			iNdEx = postIndex
  8006  		case 4:
  8007  			if wireType != 2 {
  8008  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
  8009  			}
  8010  			var msglen int
  8011  			for shift := uint(0); ; shift += 7 {
  8012  				if shift >= 64 {
  8013  					return ErrIntOverflow
  8014  				}
  8015  				if iNdEx >= l {
  8016  					return io.ErrUnexpectedEOF
  8017  				}
  8018  				b := dAtA[iNdEx]
  8019  				iNdEx++
  8020  				msglen |= int(b&0x7F) << shift
  8021  				if b < 0x80 {
  8022  					break
  8023  				}
  8024  			}
  8025  			if msglen < 0 {
  8026  				return ErrInvalidLength
  8027  			}
  8028  			postIndex := iNdEx + msglen
  8029  			if postIndex < 0 {
  8030  				return ErrInvalidLength
  8031  			}
  8032  			if postIndex > l {
  8033  				return io.ErrUnexpectedEOF
  8034  			}
  8035  			if m.Query == nil {
  8036  				m.Query = &BoundQuery{}
  8037  			}
  8038  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8039  				return err
  8040  			}
  8041  			iNdEx = postIndex
  8042  		case 5:
  8043  			if wireType != 0 {
  8044  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
  8045  			}
  8046  			m.TransactionId = 0
  8047  			for shift := uint(0); ; shift += 7 {
  8048  				if shift >= 64 {
  8049  					return ErrIntOverflow
  8050  				}
  8051  				if iNdEx >= l {
  8052  					return io.ErrUnexpectedEOF
  8053  				}
  8054  				b := dAtA[iNdEx]
  8055  				iNdEx++
  8056  				m.TransactionId |= int64(b&0x7F) << shift
  8057  				if b < 0x80 {
  8058  					break
  8059  				}
  8060  			}
  8061  		case 6:
  8062  			if wireType != 2 {
  8063  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
  8064  			}
  8065  			var msglen int
  8066  			for shift := uint(0); ; shift += 7 {
  8067  				if shift >= 64 {
  8068  					return ErrIntOverflow
  8069  				}
  8070  				if iNdEx >= l {
  8071  					return io.ErrUnexpectedEOF
  8072  				}
  8073  				b := dAtA[iNdEx]
  8074  				iNdEx++
  8075  				msglen |= int(b&0x7F) << shift
  8076  				if b < 0x80 {
  8077  					break
  8078  				}
  8079  			}
  8080  			if msglen < 0 {
  8081  				return ErrInvalidLength
  8082  			}
  8083  			postIndex := iNdEx + msglen
  8084  			if postIndex < 0 {
  8085  				return ErrInvalidLength
  8086  			}
  8087  			if postIndex > l {
  8088  				return io.ErrUnexpectedEOF
  8089  			}
  8090  			if m.Options == nil {
  8091  				m.Options = &ExecuteOptions{}
  8092  			}
  8093  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8094  				return err
  8095  			}
  8096  			iNdEx = postIndex
  8097  		case 7:
  8098  			if wireType != 0 {
  8099  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
  8100  			}
  8101  			m.ReservedId = 0
  8102  			for shift := uint(0); ; shift += 7 {
  8103  				if shift >= 64 {
  8104  					return ErrIntOverflow
  8105  				}
  8106  				if iNdEx >= l {
  8107  					return io.ErrUnexpectedEOF
  8108  				}
  8109  				b := dAtA[iNdEx]
  8110  				iNdEx++
  8111  				m.ReservedId |= int64(b&0x7F) << shift
  8112  				if b < 0x80 {
  8113  					break
  8114  				}
  8115  			}
  8116  		default:
  8117  			iNdEx = preIndex
  8118  			skippy, err := skip(dAtA[iNdEx:])
  8119  			if err != nil {
  8120  				return err
  8121  			}
  8122  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8123  				return ErrInvalidLength
  8124  			}
  8125  			if (iNdEx + skippy) > l {
  8126  				return io.ErrUnexpectedEOF
  8127  			}
  8128  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8129  			iNdEx += skippy
  8130  		}
  8131  	}
  8132  
  8133  	if iNdEx > l {
  8134  		return io.ErrUnexpectedEOF
  8135  	}
  8136  	return nil
  8137  }
  8138  func (m *ExecuteResponse) UnmarshalVT(dAtA []byte) error {
  8139  	l := len(dAtA)
  8140  	iNdEx := 0
  8141  	for iNdEx < l {
  8142  		preIndex := iNdEx
  8143  		var wire uint64
  8144  		for shift := uint(0); ; shift += 7 {
  8145  			if shift >= 64 {
  8146  				return ErrIntOverflow
  8147  			}
  8148  			if iNdEx >= l {
  8149  				return io.ErrUnexpectedEOF
  8150  			}
  8151  			b := dAtA[iNdEx]
  8152  			iNdEx++
  8153  			wire |= uint64(b&0x7F) << shift
  8154  			if b < 0x80 {
  8155  				break
  8156  			}
  8157  		}
  8158  		fieldNum := int32(wire >> 3)
  8159  		wireType := int(wire & 0x7)
  8160  		if wireType == 4 {
  8161  			return fmt.Errorf("proto: ExecuteResponse: wiretype end group for non-group")
  8162  		}
  8163  		if fieldNum <= 0 {
  8164  			return fmt.Errorf("proto: ExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8165  		}
  8166  		switch fieldNum {
  8167  		case 1:
  8168  			if wireType != 2 {
  8169  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
  8170  			}
  8171  			var msglen int
  8172  			for shift := uint(0); ; shift += 7 {
  8173  				if shift >= 64 {
  8174  					return ErrIntOverflow
  8175  				}
  8176  				if iNdEx >= l {
  8177  					return io.ErrUnexpectedEOF
  8178  				}
  8179  				b := dAtA[iNdEx]
  8180  				iNdEx++
  8181  				msglen |= int(b&0x7F) << shift
  8182  				if b < 0x80 {
  8183  					break
  8184  				}
  8185  			}
  8186  			if msglen < 0 {
  8187  				return ErrInvalidLength
  8188  			}
  8189  			postIndex := iNdEx + msglen
  8190  			if postIndex < 0 {
  8191  				return ErrInvalidLength
  8192  			}
  8193  			if postIndex > l {
  8194  				return io.ErrUnexpectedEOF
  8195  			}
  8196  			if m.Result == nil {
  8197  				m.Result = &QueryResult{}
  8198  			}
  8199  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8200  				return err
  8201  			}
  8202  			iNdEx = postIndex
  8203  		default:
  8204  			iNdEx = preIndex
  8205  			skippy, err := skip(dAtA[iNdEx:])
  8206  			if err != nil {
  8207  				return err
  8208  			}
  8209  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8210  				return ErrInvalidLength
  8211  			}
  8212  			if (iNdEx + skippy) > l {
  8213  				return io.ErrUnexpectedEOF
  8214  			}
  8215  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8216  			iNdEx += skippy
  8217  		}
  8218  	}
  8219  
  8220  	if iNdEx > l {
  8221  		return io.ErrUnexpectedEOF
  8222  	}
  8223  	return nil
  8224  }
  8225  func (m *ResultWithError) UnmarshalVT(dAtA []byte) error {
  8226  	l := len(dAtA)
  8227  	iNdEx := 0
  8228  	for iNdEx < l {
  8229  		preIndex := iNdEx
  8230  		var wire uint64
  8231  		for shift := uint(0); ; shift += 7 {
  8232  			if shift >= 64 {
  8233  				return ErrIntOverflow
  8234  			}
  8235  			if iNdEx >= l {
  8236  				return io.ErrUnexpectedEOF
  8237  			}
  8238  			b := dAtA[iNdEx]
  8239  			iNdEx++
  8240  			wire |= uint64(b&0x7F) << shift
  8241  			if b < 0x80 {
  8242  				break
  8243  			}
  8244  		}
  8245  		fieldNum := int32(wire >> 3)
  8246  		wireType := int(wire & 0x7)
  8247  		if wireType == 4 {
  8248  			return fmt.Errorf("proto: ResultWithError: wiretype end group for non-group")
  8249  		}
  8250  		if fieldNum <= 0 {
  8251  			return fmt.Errorf("proto: ResultWithError: illegal tag %d (wire type %d)", fieldNum, wire)
  8252  		}
  8253  		switch fieldNum {
  8254  		case 1:
  8255  			if wireType != 2 {
  8256  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
  8257  			}
  8258  			var msglen int
  8259  			for shift := uint(0); ; shift += 7 {
  8260  				if shift >= 64 {
  8261  					return ErrIntOverflow
  8262  				}
  8263  				if iNdEx >= l {
  8264  					return io.ErrUnexpectedEOF
  8265  				}
  8266  				b := dAtA[iNdEx]
  8267  				iNdEx++
  8268  				msglen |= int(b&0x7F) << shift
  8269  				if b < 0x80 {
  8270  					break
  8271  				}
  8272  			}
  8273  			if msglen < 0 {
  8274  				return ErrInvalidLength
  8275  			}
  8276  			postIndex := iNdEx + msglen
  8277  			if postIndex < 0 {
  8278  				return ErrInvalidLength
  8279  			}
  8280  			if postIndex > l {
  8281  				return io.ErrUnexpectedEOF
  8282  			}
  8283  			if m.Error == nil {
  8284  				m.Error = &vtrpc.RPCError{}
  8285  			}
  8286  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8287  				return err
  8288  			}
  8289  			iNdEx = postIndex
  8290  		case 2:
  8291  			if wireType != 2 {
  8292  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
  8293  			}
  8294  			var msglen int
  8295  			for shift := uint(0); ; shift += 7 {
  8296  				if shift >= 64 {
  8297  					return ErrIntOverflow
  8298  				}
  8299  				if iNdEx >= l {
  8300  					return io.ErrUnexpectedEOF
  8301  				}
  8302  				b := dAtA[iNdEx]
  8303  				iNdEx++
  8304  				msglen |= int(b&0x7F) << shift
  8305  				if b < 0x80 {
  8306  					break
  8307  				}
  8308  			}
  8309  			if msglen < 0 {
  8310  				return ErrInvalidLength
  8311  			}
  8312  			postIndex := iNdEx + msglen
  8313  			if postIndex < 0 {
  8314  				return ErrInvalidLength
  8315  			}
  8316  			if postIndex > l {
  8317  				return io.ErrUnexpectedEOF
  8318  			}
  8319  			if m.Result == nil {
  8320  				m.Result = &QueryResult{}
  8321  			}
  8322  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8323  				return err
  8324  			}
  8325  			iNdEx = postIndex
  8326  		default:
  8327  			iNdEx = preIndex
  8328  			skippy, err := skip(dAtA[iNdEx:])
  8329  			if err != nil {
  8330  				return err
  8331  			}
  8332  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8333  				return ErrInvalidLength
  8334  			}
  8335  			if (iNdEx + skippy) > l {
  8336  				return io.ErrUnexpectedEOF
  8337  			}
  8338  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8339  			iNdEx += skippy
  8340  		}
  8341  	}
  8342  
  8343  	if iNdEx > l {
  8344  		return io.ErrUnexpectedEOF
  8345  	}
  8346  	return nil
  8347  }
  8348  func (m *StreamExecuteRequest) UnmarshalVT(dAtA []byte) error {
  8349  	l := len(dAtA)
  8350  	iNdEx := 0
  8351  	for iNdEx < l {
  8352  		preIndex := iNdEx
  8353  		var wire uint64
  8354  		for shift := uint(0); ; shift += 7 {
  8355  			if shift >= 64 {
  8356  				return ErrIntOverflow
  8357  			}
  8358  			if iNdEx >= l {
  8359  				return io.ErrUnexpectedEOF
  8360  			}
  8361  			b := dAtA[iNdEx]
  8362  			iNdEx++
  8363  			wire |= uint64(b&0x7F) << shift
  8364  			if b < 0x80 {
  8365  				break
  8366  			}
  8367  		}
  8368  		fieldNum := int32(wire >> 3)
  8369  		wireType := int(wire & 0x7)
  8370  		if wireType == 4 {
  8371  			return fmt.Errorf("proto: StreamExecuteRequest: wiretype end group for non-group")
  8372  		}
  8373  		if fieldNum <= 0 {
  8374  			return fmt.Errorf("proto: StreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8375  		}
  8376  		switch fieldNum {
  8377  		case 1:
  8378  			if wireType != 2 {
  8379  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  8380  			}
  8381  			var msglen int
  8382  			for shift := uint(0); ; shift += 7 {
  8383  				if shift >= 64 {
  8384  					return ErrIntOverflow
  8385  				}
  8386  				if iNdEx >= l {
  8387  					return io.ErrUnexpectedEOF
  8388  				}
  8389  				b := dAtA[iNdEx]
  8390  				iNdEx++
  8391  				msglen |= int(b&0x7F) << shift
  8392  				if b < 0x80 {
  8393  					break
  8394  				}
  8395  			}
  8396  			if msglen < 0 {
  8397  				return ErrInvalidLength
  8398  			}
  8399  			postIndex := iNdEx + msglen
  8400  			if postIndex < 0 {
  8401  				return ErrInvalidLength
  8402  			}
  8403  			if postIndex > l {
  8404  				return io.ErrUnexpectedEOF
  8405  			}
  8406  			if m.EffectiveCallerId == nil {
  8407  				m.EffectiveCallerId = &vtrpc.CallerID{}
  8408  			}
  8409  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8410  				return err
  8411  			}
  8412  			iNdEx = postIndex
  8413  		case 2:
  8414  			if wireType != 2 {
  8415  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  8416  			}
  8417  			var msglen int
  8418  			for shift := uint(0); ; shift += 7 {
  8419  				if shift >= 64 {
  8420  					return ErrIntOverflow
  8421  				}
  8422  				if iNdEx >= l {
  8423  					return io.ErrUnexpectedEOF
  8424  				}
  8425  				b := dAtA[iNdEx]
  8426  				iNdEx++
  8427  				msglen |= int(b&0x7F) << shift
  8428  				if b < 0x80 {
  8429  					break
  8430  				}
  8431  			}
  8432  			if msglen < 0 {
  8433  				return ErrInvalidLength
  8434  			}
  8435  			postIndex := iNdEx + msglen
  8436  			if postIndex < 0 {
  8437  				return ErrInvalidLength
  8438  			}
  8439  			if postIndex > l {
  8440  				return io.ErrUnexpectedEOF
  8441  			}
  8442  			if m.ImmediateCallerId == nil {
  8443  				m.ImmediateCallerId = &VTGateCallerID{}
  8444  			}
  8445  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8446  				return err
  8447  			}
  8448  			iNdEx = postIndex
  8449  		case 3:
  8450  			if wireType != 2 {
  8451  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  8452  			}
  8453  			var msglen int
  8454  			for shift := uint(0); ; shift += 7 {
  8455  				if shift >= 64 {
  8456  					return ErrIntOverflow
  8457  				}
  8458  				if iNdEx >= l {
  8459  					return io.ErrUnexpectedEOF
  8460  				}
  8461  				b := dAtA[iNdEx]
  8462  				iNdEx++
  8463  				msglen |= int(b&0x7F) << shift
  8464  				if b < 0x80 {
  8465  					break
  8466  				}
  8467  			}
  8468  			if msglen < 0 {
  8469  				return ErrInvalidLength
  8470  			}
  8471  			postIndex := iNdEx + msglen
  8472  			if postIndex < 0 {
  8473  				return ErrInvalidLength
  8474  			}
  8475  			if postIndex > l {
  8476  				return io.ErrUnexpectedEOF
  8477  			}
  8478  			if m.Target == nil {
  8479  				m.Target = &Target{}
  8480  			}
  8481  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8482  				return err
  8483  			}
  8484  			iNdEx = postIndex
  8485  		case 4:
  8486  			if wireType != 2 {
  8487  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
  8488  			}
  8489  			var msglen int
  8490  			for shift := uint(0); ; shift += 7 {
  8491  				if shift >= 64 {
  8492  					return ErrIntOverflow
  8493  				}
  8494  				if iNdEx >= l {
  8495  					return io.ErrUnexpectedEOF
  8496  				}
  8497  				b := dAtA[iNdEx]
  8498  				iNdEx++
  8499  				msglen |= int(b&0x7F) << shift
  8500  				if b < 0x80 {
  8501  					break
  8502  				}
  8503  			}
  8504  			if msglen < 0 {
  8505  				return ErrInvalidLength
  8506  			}
  8507  			postIndex := iNdEx + msglen
  8508  			if postIndex < 0 {
  8509  				return ErrInvalidLength
  8510  			}
  8511  			if postIndex > l {
  8512  				return io.ErrUnexpectedEOF
  8513  			}
  8514  			if m.Query == nil {
  8515  				m.Query = &BoundQuery{}
  8516  			}
  8517  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8518  				return err
  8519  			}
  8520  			iNdEx = postIndex
  8521  		case 5:
  8522  			if wireType != 2 {
  8523  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
  8524  			}
  8525  			var msglen int
  8526  			for shift := uint(0); ; shift += 7 {
  8527  				if shift >= 64 {
  8528  					return ErrIntOverflow
  8529  				}
  8530  				if iNdEx >= l {
  8531  					return io.ErrUnexpectedEOF
  8532  				}
  8533  				b := dAtA[iNdEx]
  8534  				iNdEx++
  8535  				msglen |= int(b&0x7F) << shift
  8536  				if b < 0x80 {
  8537  					break
  8538  				}
  8539  			}
  8540  			if msglen < 0 {
  8541  				return ErrInvalidLength
  8542  			}
  8543  			postIndex := iNdEx + msglen
  8544  			if postIndex < 0 {
  8545  				return ErrInvalidLength
  8546  			}
  8547  			if postIndex > l {
  8548  				return io.ErrUnexpectedEOF
  8549  			}
  8550  			if m.Options == nil {
  8551  				m.Options = &ExecuteOptions{}
  8552  			}
  8553  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8554  				return err
  8555  			}
  8556  			iNdEx = postIndex
  8557  		case 6:
  8558  			if wireType != 0 {
  8559  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
  8560  			}
  8561  			m.TransactionId = 0
  8562  			for shift := uint(0); ; shift += 7 {
  8563  				if shift >= 64 {
  8564  					return ErrIntOverflow
  8565  				}
  8566  				if iNdEx >= l {
  8567  					return io.ErrUnexpectedEOF
  8568  				}
  8569  				b := dAtA[iNdEx]
  8570  				iNdEx++
  8571  				m.TransactionId |= int64(b&0x7F) << shift
  8572  				if b < 0x80 {
  8573  					break
  8574  				}
  8575  			}
  8576  		case 7:
  8577  			if wireType != 0 {
  8578  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
  8579  			}
  8580  			m.ReservedId = 0
  8581  			for shift := uint(0); ; shift += 7 {
  8582  				if shift >= 64 {
  8583  					return ErrIntOverflow
  8584  				}
  8585  				if iNdEx >= l {
  8586  					return io.ErrUnexpectedEOF
  8587  				}
  8588  				b := dAtA[iNdEx]
  8589  				iNdEx++
  8590  				m.ReservedId |= int64(b&0x7F) << shift
  8591  				if b < 0x80 {
  8592  					break
  8593  				}
  8594  			}
  8595  		default:
  8596  			iNdEx = preIndex
  8597  			skippy, err := skip(dAtA[iNdEx:])
  8598  			if err != nil {
  8599  				return err
  8600  			}
  8601  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8602  				return ErrInvalidLength
  8603  			}
  8604  			if (iNdEx + skippy) > l {
  8605  				return io.ErrUnexpectedEOF
  8606  			}
  8607  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8608  			iNdEx += skippy
  8609  		}
  8610  	}
  8611  
  8612  	if iNdEx > l {
  8613  		return io.ErrUnexpectedEOF
  8614  	}
  8615  	return nil
  8616  }
  8617  func (m *StreamExecuteResponse) UnmarshalVT(dAtA []byte) error {
  8618  	l := len(dAtA)
  8619  	iNdEx := 0
  8620  	for iNdEx < l {
  8621  		preIndex := iNdEx
  8622  		var wire uint64
  8623  		for shift := uint(0); ; shift += 7 {
  8624  			if shift >= 64 {
  8625  				return ErrIntOverflow
  8626  			}
  8627  			if iNdEx >= l {
  8628  				return io.ErrUnexpectedEOF
  8629  			}
  8630  			b := dAtA[iNdEx]
  8631  			iNdEx++
  8632  			wire |= uint64(b&0x7F) << shift
  8633  			if b < 0x80 {
  8634  				break
  8635  			}
  8636  		}
  8637  		fieldNum := int32(wire >> 3)
  8638  		wireType := int(wire & 0x7)
  8639  		if wireType == 4 {
  8640  			return fmt.Errorf("proto: StreamExecuteResponse: wiretype end group for non-group")
  8641  		}
  8642  		if fieldNum <= 0 {
  8643  			return fmt.Errorf("proto: StreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8644  		}
  8645  		switch fieldNum {
  8646  		case 1:
  8647  			if wireType != 2 {
  8648  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
  8649  			}
  8650  			var msglen int
  8651  			for shift := uint(0); ; shift += 7 {
  8652  				if shift >= 64 {
  8653  					return ErrIntOverflow
  8654  				}
  8655  				if iNdEx >= l {
  8656  					return io.ErrUnexpectedEOF
  8657  				}
  8658  				b := dAtA[iNdEx]
  8659  				iNdEx++
  8660  				msglen |= int(b&0x7F) << shift
  8661  				if b < 0x80 {
  8662  					break
  8663  				}
  8664  			}
  8665  			if msglen < 0 {
  8666  				return ErrInvalidLength
  8667  			}
  8668  			postIndex := iNdEx + msglen
  8669  			if postIndex < 0 {
  8670  				return ErrInvalidLength
  8671  			}
  8672  			if postIndex > l {
  8673  				return io.ErrUnexpectedEOF
  8674  			}
  8675  			if m.Result == nil {
  8676  				m.Result = &QueryResult{}
  8677  			}
  8678  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8679  				return err
  8680  			}
  8681  			iNdEx = postIndex
  8682  		default:
  8683  			iNdEx = preIndex
  8684  			skippy, err := skip(dAtA[iNdEx:])
  8685  			if err != nil {
  8686  				return err
  8687  			}
  8688  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8689  				return ErrInvalidLength
  8690  			}
  8691  			if (iNdEx + skippy) > l {
  8692  				return io.ErrUnexpectedEOF
  8693  			}
  8694  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8695  			iNdEx += skippy
  8696  		}
  8697  	}
  8698  
  8699  	if iNdEx > l {
  8700  		return io.ErrUnexpectedEOF
  8701  	}
  8702  	return nil
  8703  }
  8704  func (m *BeginRequest) UnmarshalVT(dAtA []byte) error {
  8705  	l := len(dAtA)
  8706  	iNdEx := 0
  8707  	for iNdEx < l {
  8708  		preIndex := iNdEx
  8709  		var wire uint64
  8710  		for shift := uint(0); ; shift += 7 {
  8711  			if shift >= 64 {
  8712  				return ErrIntOverflow
  8713  			}
  8714  			if iNdEx >= l {
  8715  				return io.ErrUnexpectedEOF
  8716  			}
  8717  			b := dAtA[iNdEx]
  8718  			iNdEx++
  8719  			wire |= uint64(b&0x7F) << shift
  8720  			if b < 0x80 {
  8721  				break
  8722  			}
  8723  		}
  8724  		fieldNum := int32(wire >> 3)
  8725  		wireType := int(wire & 0x7)
  8726  		if wireType == 4 {
  8727  			return fmt.Errorf("proto: BeginRequest: wiretype end group for non-group")
  8728  		}
  8729  		if fieldNum <= 0 {
  8730  			return fmt.Errorf("proto: BeginRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8731  		}
  8732  		switch fieldNum {
  8733  		case 1:
  8734  			if wireType != 2 {
  8735  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  8736  			}
  8737  			var msglen int
  8738  			for shift := uint(0); ; shift += 7 {
  8739  				if shift >= 64 {
  8740  					return ErrIntOverflow
  8741  				}
  8742  				if iNdEx >= l {
  8743  					return io.ErrUnexpectedEOF
  8744  				}
  8745  				b := dAtA[iNdEx]
  8746  				iNdEx++
  8747  				msglen |= int(b&0x7F) << shift
  8748  				if b < 0x80 {
  8749  					break
  8750  				}
  8751  			}
  8752  			if msglen < 0 {
  8753  				return ErrInvalidLength
  8754  			}
  8755  			postIndex := iNdEx + msglen
  8756  			if postIndex < 0 {
  8757  				return ErrInvalidLength
  8758  			}
  8759  			if postIndex > l {
  8760  				return io.ErrUnexpectedEOF
  8761  			}
  8762  			if m.EffectiveCallerId == nil {
  8763  				m.EffectiveCallerId = &vtrpc.CallerID{}
  8764  			}
  8765  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8766  				return err
  8767  			}
  8768  			iNdEx = postIndex
  8769  		case 2:
  8770  			if wireType != 2 {
  8771  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  8772  			}
  8773  			var msglen int
  8774  			for shift := uint(0); ; shift += 7 {
  8775  				if shift >= 64 {
  8776  					return ErrIntOverflow
  8777  				}
  8778  				if iNdEx >= l {
  8779  					return io.ErrUnexpectedEOF
  8780  				}
  8781  				b := dAtA[iNdEx]
  8782  				iNdEx++
  8783  				msglen |= int(b&0x7F) << shift
  8784  				if b < 0x80 {
  8785  					break
  8786  				}
  8787  			}
  8788  			if msglen < 0 {
  8789  				return ErrInvalidLength
  8790  			}
  8791  			postIndex := iNdEx + msglen
  8792  			if postIndex < 0 {
  8793  				return ErrInvalidLength
  8794  			}
  8795  			if postIndex > l {
  8796  				return io.ErrUnexpectedEOF
  8797  			}
  8798  			if m.ImmediateCallerId == nil {
  8799  				m.ImmediateCallerId = &VTGateCallerID{}
  8800  			}
  8801  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8802  				return err
  8803  			}
  8804  			iNdEx = postIndex
  8805  		case 3:
  8806  			if wireType != 2 {
  8807  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  8808  			}
  8809  			var msglen int
  8810  			for shift := uint(0); ; shift += 7 {
  8811  				if shift >= 64 {
  8812  					return ErrIntOverflow
  8813  				}
  8814  				if iNdEx >= l {
  8815  					return io.ErrUnexpectedEOF
  8816  				}
  8817  				b := dAtA[iNdEx]
  8818  				iNdEx++
  8819  				msglen |= int(b&0x7F) << shift
  8820  				if b < 0x80 {
  8821  					break
  8822  				}
  8823  			}
  8824  			if msglen < 0 {
  8825  				return ErrInvalidLength
  8826  			}
  8827  			postIndex := iNdEx + msglen
  8828  			if postIndex < 0 {
  8829  				return ErrInvalidLength
  8830  			}
  8831  			if postIndex > l {
  8832  				return io.ErrUnexpectedEOF
  8833  			}
  8834  			if m.Target == nil {
  8835  				m.Target = &Target{}
  8836  			}
  8837  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8838  				return err
  8839  			}
  8840  			iNdEx = postIndex
  8841  		case 4:
  8842  			if wireType != 2 {
  8843  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
  8844  			}
  8845  			var msglen int
  8846  			for shift := uint(0); ; shift += 7 {
  8847  				if shift >= 64 {
  8848  					return ErrIntOverflow
  8849  				}
  8850  				if iNdEx >= l {
  8851  					return io.ErrUnexpectedEOF
  8852  				}
  8853  				b := dAtA[iNdEx]
  8854  				iNdEx++
  8855  				msglen |= int(b&0x7F) << shift
  8856  				if b < 0x80 {
  8857  					break
  8858  				}
  8859  			}
  8860  			if msglen < 0 {
  8861  				return ErrInvalidLength
  8862  			}
  8863  			postIndex := iNdEx + msglen
  8864  			if postIndex < 0 {
  8865  				return ErrInvalidLength
  8866  			}
  8867  			if postIndex > l {
  8868  				return io.ErrUnexpectedEOF
  8869  			}
  8870  			if m.Options == nil {
  8871  				m.Options = &ExecuteOptions{}
  8872  			}
  8873  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8874  				return err
  8875  			}
  8876  			iNdEx = postIndex
  8877  		default:
  8878  			iNdEx = preIndex
  8879  			skippy, err := skip(dAtA[iNdEx:])
  8880  			if err != nil {
  8881  				return err
  8882  			}
  8883  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8884  				return ErrInvalidLength
  8885  			}
  8886  			if (iNdEx + skippy) > l {
  8887  				return io.ErrUnexpectedEOF
  8888  			}
  8889  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8890  			iNdEx += skippy
  8891  		}
  8892  	}
  8893  
  8894  	if iNdEx > l {
  8895  		return io.ErrUnexpectedEOF
  8896  	}
  8897  	return nil
  8898  }
  8899  func (m *BeginResponse) UnmarshalVT(dAtA []byte) error {
  8900  	l := len(dAtA)
  8901  	iNdEx := 0
  8902  	for iNdEx < l {
  8903  		preIndex := iNdEx
  8904  		var wire uint64
  8905  		for shift := uint(0); ; shift += 7 {
  8906  			if shift >= 64 {
  8907  				return ErrIntOverflow
  8908  			}
  8909  			if iNdEx >= l {
  8910  				return io.ErrUnexpectedEOF
  8911  			}
  8912  			b := dAtA[iNdEx]
  8913  			iNdEx++
  8914  			wire |= uint64(b&0x7F) << shift
  8915  			if b < 0x80 {
  8916  				break
  8917  			}
  8918  		}
  8919  		fieldNum := int32(wire >> 3)
  8920  		wireType := int(wire & 0x7)
  8921  		if wireType == 4 {
  8922  			return fmt.Errorf("proto: BeginResponse: wiretype end group for non-group")
  8923  		}
  8924  		if fieldNum <= 0 {
  8925  			return fmt.Errorf("proto: BeginResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8926  		}
  8927  		switch fieldNum {
  8928  		case 1:
  8929  			if wireType != 0 {
  8930  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
  8931  			}
  8932  			m.TransactionId = 0
  8933  			for shift := uint(0); ; shift += 7 {
  8934  				if shift >= 64 {
  8935  					return ErrIntOverflow
  8936  				}
  8937  				if iNdEx >= l {
  8938  					return io.ErrUnexpectedEOF
  8939  				}
  8940  				b := dAtA[iNdEx]
  8941  				iNdEx++
  8942  				m.TransactionId |= int64(b&0x7F) << shift
  8943  				if b < 0x80 {
  8944  					break
  8945  				}
  8946  			}
  8947  		case 2:
  8948  			if wireType != 2 {
  8949  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
  8950  			}
  8951  			var msglen int
  8952  			for shift := uint(0); ; shift += 7 {
  8953  				if shift >= 64 {
  8954  					return ErrIntOverflow
  8955  				}
  8956  				if iNdEx >= l {
  8957  					return io.ErrUnexpectedEOF
  8958  				}
  8959  				b := dAtA[iNdEx]
  8960  				iNdEx++
  8961  				msglen |= int(b&0x7F) << shift
  8962  				if b < 0x80 {
  8963  					break
  8964  				}
  8965  			}
  8966  			if msglen < 0 {
  8967  				return ErrInvalidLength
  8968  			}
  8969  			postIndex := iNdEx + msglen
  8970  			if postIndex < 0 {
  8971  				return ErrInvalidLength
  8972  			}
  8973  			if postIndex > l {
  8974  				return io.ErrUnexpectedEOF
  8975  			}
  8976  			if m.TabletAlias == nil {
  8977  				m.TabletAlias = &topodata.TabletAlias{}
  8978  			}
  8979  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8980  				return err
  8981  			}
  8982  			iNdEx = postIndex
  8983  		default:
  8984  			iNdEx = preIndex
  8985  			skippy, err := skip(dAtA[iNdEx:])
  8986  			if err != nil {
  8987  				return err
  8988  			}
  8989  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8990  				return ErrInvalidLength
  8991  			}
  8992  			if (iNdEx + skippy) > l {
  8993  				return io.ErrUnexpectedEOF
  8994  			}
  8995  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8996  			iNdEx += skippy
  8997  		}
  8998  	}
  8999  
  9000  	if iNdEx > l {
  9001  		return io.ErrUnexpectedEOF
  9002  	}
  9003  	return nil
  9004  }
  9005  func (m *CommitRequest) UnmarshalVT(dAtA []byte) error {
  9006  	l := len(dAtA)
  9007  	iNdEx := 0
  9008  	for iNdEx < l {
  9009  		preIndex := iNdEx
  9010  		var wire uint64
  9011  		for shift := uint(0); ; shift += 7 {
  9012  			if shift >= 64 {
  9013  				return ErrIntOverflow
  9014  			}
  9015  			if iNdEx >= l {
  9016  				return io.ErrUnexpectedEOF
  9017  			}
  9018  			b := dAtA[iNdEx]
  9019  			iNdEx++
  9020  			wire |= uint64(b&0x7F) << shift
  9021  			if b < 0x80 {
  9022  				break
  9023  			}
  9024  		}
  9025  		fieldNum := int32(wire >> 3)
  9026  		wireType := int(wire & 0x7)
  9027  		if wireType == 4 {
  9028  			return fmt.Errorf("proto: CommitRequest: wiretype end group for non-group")
  9029  		}
  9030  		if fieldNum <= 0 {
  9031  			return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9032  		}
  9033  		switch fieldNum {
  9034  		case 1:
  9035  			if wireType != 2 {
  9036  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  9037  			}
  9038  			var msglen int
  9039  			for shift := uint(0); ; shift += 7 {
  9040  				if shift >= 64 {
  9041  					return ErrIntOverflow
  9042  				}
  9043  				if iNdEx >= l {
  9044  					return io.ErrUnexpectedEOF
  9045  				}
  9046  				b := dAtA[iNdEx]
  9047  				iNdEx++
  9048  				msglen |= int(b&0x7F) << shift
  9049  				if b < 0x80 {
  9050  					break
  9051  				}
  9052  			}
  9053  			if msglen < 0 {
  9054  				return ErrInvalidLength
  9055  			}
  9056  			postIndex := iNdEx + msglen
  9057  			if postIndex < 0 {
  9058  				return ErrInvalidLength
  9059  			}
  9060  			if postIndex > l {
  9061  				return io.ErrUnexpectedEOF
  9062  			}
  9063  			if m.EffectiveCallerId == nil {
  9064  				m.EffectiveCallerId = &vtrpc.CallerID{}
  9065  			}
  9066  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9067  				return err
  9068  			}
  9069  			iNdEx = postIndex
  9070  		case 2:
  9071  			if wireType != 2 {
  9072  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  9073  			}
  9074  			var msglen int
  9075  			for shift := uint(0); ; shift += 7 {
  9076  				if shift >= 64 {
  9077  					return ErrIntOverflow
  9078  				}
  9079  				if iNdEx >= l {
  9080  					return io.ErrUnexpectedEOF
  9081  				}
  9082  				b := dAtA[iNdEx]
  9083  				iNdEx++
  9084  				msglen |= int(b&0x7F) << shift
  9085  				if b < 0x80 {
  9086  					break
  9087  				}
  9088  			}
  9089  			if msglen < 0 {
  9090  				return ErrInvalidLength
  9091  			}
  9092  			postIndex := iNdEx + msglen
  9093  			if postIndex < 0 {
  9094  				return ErrInvalidLength
  9095  			}
  9096  			if postIndex > l {
  9097  				return io.ErrUnexpectedEOF
  9098  			}
  9099  			if m.ImmediateCallerId == nil {
  9100  				m.ImmediateCallerId = &VTGateCallerID{}
  9101  			}
  9102  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9103  				return err
  9104  			}
  9105  			iNdEx = postIndex
  9106  		case 3:
  9107  			if wireType != 2 {
  9108  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  9109  			}
  9110  			var msglen int
  9111  			for shift := uint(0); ; shift += 7 {
  9112  				if shift >= 64 {
  9113  					return ErrIntOverflow
  9114  				}
  9115  				if iNdEx >= l {
  9116  					return io.ErrUnexpectedEOF
  9117  				}
  9118  				b := dAtA[iNdEx]
  9119  				iNdEx++
  9120  				msglen |= int(b&0x7F) << shift
  9121  				if b < 0x80 {
  9122  					break
  9123  				}
  9124  			}
  9125  			if msglen < 0 {
  9126  				return ErrInvalidLength
  9127  			}
  9128  			postIndex := iNdEx + msglen
  9129  			if postIndex < 0 {
  9130  				return ErrInvalidLength
  9131  			}
  9132  			if postIndex > l {
  9133  				return io.ErrUnexpectedEOF
  9134  			}
  9135  			if m.Target == nil {
  9136  				m.Target = &Target{}
  9137  			}
  9138  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9139  				return err
  9140  			}
  9141  			iNdEx = postIndex
  9142  		case 4:
  9143  			if wireType != 0 {
  9144  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
  9145  			}
  9146  			m.TransactionId = 0
  9147  			for shift := uint(0); ; shift += 7 {
  9148  				if shift >= 64 {
  9149  					return ErrIntOverflow
  9150  				}
  9151  				if iNdEx >= l {
  9152  					return io.ErrUnexpectedEOF
  9153  				}
  9154  				b := dAtA[iNdEx]
  9155  				iNdEx++
  9156  				m.TransactionId |= int64(b&0x7F) << shift
  9157  				if b < 0x80 {
  9158  					break
  9159  				}
  9160  			}
  9161  		default:
  9162  			iNdEx = preIndex
  9163  			skippy, err := skip(dAtA[iNdEx:])
  9164  			if err != nil {
  9165  				return err
  9166  			}
  9167  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9168  				return ErrInvalidLength
  9169  			}
  9170  			if (iNdEx + skippy) > l {
  9171  				return io.ErrUnexpectedEOF
  9172  			}
  9173  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9174  			iNdEx += skippy
  9175  		}
  9176  	}
  9177  
  9178  	if iNdEx > l {
  9179  		return io.ErrUnexpectedEOF
  9180  	}
  9181  	return nil
  9182  }
  9183  func (m *CommitResponse) UnmarshalVT(dAtA []byte) error {
  9184  	l := len(dAtA)
  9185  	iNdEx := 0
  9186  	for iNdEx < l {
  9187  		preIndex := iNdEx
  9188  		var wire uint64
  9189  		for shift := uint(0); ; shift += 7 {
  9190  			if shift >= 64 {
  9191  				return ErrIntOverflow
  9192  			}
  9193  			if iNdEx >= l {
  9194  				return io.ErrUnexpectedEOF
  9195  			}
  9196  			b := dAtA[iNdEx]
  9197  			iNdEx++
  9198  			wire |= uint64(b&0x7F) << shift
  9199  			if b < 0x80 {
  9200  				break
  9201  			}
  9202  		}
  9203  		fieldNum := int32(wire >> 3)
  9204  		wireType := int(wire & 0x7)
  9205  		if wireType == 4 {
  9206  			return fmt.Errorf("proto: CommitResponse: wiretype end group for non-group")
  9207  		}
  9208  		if fieldNum <= 0 {
  9209  			return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9210  		}
  9211  		switch fieldNum {
  9212  		case 1:
  9213  			if wireType != 0 {
  9214  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
  9215  			}
  9216  			m.ReservedId = 0
  9217  			for shift := uint(0); ; shift += 7 {
  9218  				if shift >= 64 {
  9219  					return ErrIntOverflow
  9220  				}
  9221  				if iNdEx >= l {
  9222  					return io.ErrUnexpectedEOF
  9223  				}
  9224  				b := dAtA[iNdEx]
  9225  				iNdEx++
  9226  				m.ReservedId |= int64(b&0x7F) << shift
  9227  				if b < 0x80 {
  9228  					break
  9229  				}
  9230  			}
  9231  		default:
  9232  			iNdEx = preIndex
  9233  			skippy, err := skip(dAtA[iNdEx:])
  9234  			if err != nil {
  9235  				return err
  9236  			}
  9237  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9238  				return ErrInvalidLength
  9239  			}
  9240  			if (iNdEx + skippy) > l {
  9241  				return io.ErrUnexpectedEOF
  9242  			}
  9243  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9244  			iNdEx += skippy
  9245  		}
  9246  	}
  9247  
  9248  	if iNdEx > l {
  9249  		return io.ErrUnexpectedEOF
  9250  	}
  9251  	return nil
  9252  }
  9253  func (m *RollbackRequest) UnmarshalVT(dAtA []byte) error {
  9254  	l := len(dAtA)
  9255  	iNdEx := 0
  9256  	for iNdEx < l {
  9257  		preIndex := iNdEx
  9258  		var wire uint64
  9259  		for shift := uint(0); ; shift += 7 {
  9260  			if shift >= 64 {
  9261  				return ErrIntOverflow
  9262  			}
  9263  			if iNdEx >= l {
  9264  				return io.ErrUnexpectedEOF
  9265  			}
  9266  			b := dAtA[iNdEx]
  9267  			iNdEx++
  9268  			wire |= uint64(b&0x7F) << shift
  9269  			if b < 0x80 {
  9270  				break
  9271  			}
  9272  		}
  9273  		fieldNum := int32(wire >> 3)
  9274  		wireType := int(wire & 0x7)
  9275  		if wireType == 4 {
  9276  			return fmt.Errorf("proto: RollbackRequest: wiretype end group for non-group")
  9277  		}
  9278  		if fieldNum <= 0 {
  9279  			return fmt.Errorf("proto: RollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9280  		}
  9281  		switch fieldNum {
  9282  		case 1:
  9283  			if wireType != 2 {
  9284  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  9285  			}
  9286  			var msglen int
  9287  			for shift := uint(0); ; shift += 7 {
  9288  				if shift >= 64 {
  9289  					return ErrIntOverflow
  9290  				}
  9291  				if iNdEx >= l {
  9292  					return io.ErrUnexpectedEOF
  9293  				}
  9294  				b := dAtA[iNdEx]
  9295  				iNdEx++
  9296  				msglen |= int(b&0x7F) << shift
  9297  				if b < 0x80 {
  9298  					break
  9299  				}
  9300  			}
  9301  			if msglen < 0 {
  9302  				return ErrInvalidLength
  9303  			}
  9304  			postIndex := iNdEx + msglen
  9305  			if postIndex < 0 {
  9306  				return ErrInvalidLength
  9307  			}
  9308  			if postIndex > l {
  9309  				return io.ErrUnexpectedEOF
  9310  			}
  9311  			if m.EffectiveCallerId == nil {
  9312  				m.EffectiveCallerId = &vtrpc.CallerID{}
  9313  			}
  9314  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9315  				return err
  9316  			}
  9317  			iNdEx = postIndex
  9318  		case 2:
  9319  			if wireType != 2 {
  9320  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  9321  			}
  9322  			var msglen int
  9323  			for shift := uint(0); ; shift += 7 {
  9324  				if shift >= 64 {
  9325  					return ErrIntOverflow
  9326  				}
  9327  				if iNdEx >= l {
  9328  					return io.ErrUnexpectedEOF
  9329  				}
  9330  				b := dAtA[iNdEx]
  9331  				iNdEx++
  9332  				msglen |= int(b&0x7F) << shift
  9333  				if b < 0x80 {
  9334  					break
  9335  				}
  9336  			}
  9337  			if msglen < 0 {
  9338  				return ErrInvalidLength
  9339  			}
  9340  			postIndex := iNdEx + msglen
  9341  			if postIndex < 0 {
  9342  				return ErrInvalidLength
  9343  			}
  9344  			if postIndex > l {
  9345  				return io.ErrUnexpectedEOF
  9346  			}
  9347  			if m.ImmediateCallerId == nil {
  9348  				m.ImmediateCallerId = &VTGateCallerID{}
  9349  			}
  9350  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9351  				return err
  9352  			}
  9353  			iNdEx = postIndex
  9354  		case 3:
  9355  			if wireType != 2 {
  9356  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  9357  			}
  9358  			var msglen int
  9359  			for shift := uint(0); ; shift += 7 {
  9360  				if shift >= 64 {
  9361  					return ErrIntOverflow
  9362  				}
  9363  				if iNdEx >= l {
  9364  					return io.ErrUnexpectedEOF
  9365  				}
  9366  				b := dAtA[iNdEx]
  9367  				iNdEx++
  9368  				msglen |= int(b&0x7F) << shift
  9369  				if b < 0x80 {
  9370  					break
  9371  				}
  9372  			}
  9373  			if msglen < 0 {
  9374  				return ErrInvalidLength
  9375  			}
  9376  			postIndex := iNdEx + msglen
  9377  			if postIndex < 0 {
  9378  				return ErrInvalidLength
  9379  			}
  9380  			if postIndex > l {
  9381  				return io.ErrUnexpectedEOF
  9382  			}
  9383  			if m.Target == nil {
  9384  				m.Target = &Target{}
  9385  			}
  9386  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9387  				return err
  9388  			}
  9389  			iNdEx = postIndex
  9390  		case 4:
  9391  			if wireType != 0 {
  9392  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
  9393  			}
  9394  			m.TransactionId = 0
  9395  			for shift := uint(0); ; shift += 7 {
  9396  				if shift >= 64 {
  9397  					return ErrIntOverflow
  9398  				}
  9399  				if iNdEx >= l {
  9400  					return io.ErrUnexpectedEOF
  9401  				}
  9402  				b := dAtA[iNdEx]
  9403  				iNdEx++
  9404  				m.TransactionId |= int64(b&0x7F) << shift
  9405  				if b < 0x80 {
  9406  					break
  9407  				}
  9408  			}
  9409  		default:
  9410  			iNdEx = preIndex
  9411  			skippy, err := skip(dAtA[iNdEx:])
  9412  			if err != nil {
  9413  				return err
  9414  			}
  9415  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9416  				return ErrInvalidLength
  9417  			}
  9418  			if (iNdEx + skippy) > l {
  9419  				return io.ErrUnexpectedEOF
  9420  			}
  9421  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9422  			iNdEx += skippy
  9423  		}
  9424  	}
  9425  
  9426  	if iNdEx > l {
  9427  		return io.ErrUnexpectedEOF
  9428  	}
  9429  	return nil
  9430  }
  9431  func (m *RollbackResponse) UnmarshalVT(dAtA []byte) error {
  9432  	l := len(dAtA)
  9433  	iNdEx := 0
  9434  	for iNdEx < l {
  9435  		preIndex := iNdEx
  9436  		var wire uint64
  9437  		for shift := uint(0); ; shift += 7 {
  9438  			if shift >= 64 {
  9439  				return ErrIntOverflow
  9440  			}
  9441  			if iNdEx >= l {
  9442  				return io.ErrUnexpectedEOF
  9443  			}
  9444  			b := dAtA[iNdEx]
  9445  			iNdEx++
  9446  			wire |= uint64(b&0x7F) << shift
  9447  			if b < 0x80 {
  9448  				break
  9449  			}
  9450  		}
  9451  		fieldNum := int32(wire >> 3)
  9452  		wireType := int(wire & 0x7)
  9453  		if wireType == 4 {
  9454  			return fmt.Errorf("proto: RollbackResponse: wiretype end group for non-group")
  9455  		}
  9456  		if fieldNum <= 0 {
  9457  			return fmt.Errorf("proto: RollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9458  		}
  9459  		switch fieldNum {
  9460  		case 1:
  9461  			if wireType != 0 {
  9462  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
  9463  			}
  9464  			m.ReservedId = 0
  9465  			for shift := uint(0); ; shift += 7 {
  9466  				if shift >= 64 {
  9467  					return ErrIntOverflow
  9468  				}
  9469  				if iNdEx >= l {
  9470  					return io.ErrUnexpectedEOF
  9471  				}
  9472  				b := dAtA[iNdEx]
  9473  				iNdEx++
  9474  				m.ReservedId |= int64(b&0x7F) << shift
  9475  				if b < 0x80 {
  9476  					break
  9477  				}
  9478  			}
  9479  		default:
  9480  			iNdEx = preIndex
  9481  			skippy, err := skip(dAtA[iNdEx:])
  9482  			if err != nil {
  9483  				return err
  9484  			}
  9485  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9486  				return ErrInvalidLength
  9487  			}
  9488  			if (iNdEx + skippy) > l {
  9489  				return io.ErrUnexpectedEOF
  9490  			}
  9491  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9492  			iNdEx += skippy
  9493  		}
  9494  	}
  9495  
  9496  	if iNdEx > l {
  9497  		return io.ErrUnexpectedEOF
  9498  	}
  9499  	return nil
  9500  }
  9501  func (m *PrepareRequest) UnmarshalVT(dAtA []byte) error {
  9502  	l := len(dAtA)
  9503  	iNdEx := 0
  9504  	for iNdEx < l {
  9505  		preIndex := iNdEx
  9506  		var wire uint64
  9507  		for shift := uint(0); ; shift += 7 {
  9508  			if shift >= 64 {
  9509  				return ErrIntOverflow
  9510  			}
  9511  			if iNdEx >= l {
  9512  				return io.ErrUnexpectedEOF
  9513  			}
  9514  			b := dAtA[iNdEx]
  9515  			iNdEx++
  9516  			wire |= uint64(b&0x7F) << shift
  9517  			if b < 0x80 {
  9518  				break
  9519  			}
  9520  		}
  9521  		fieldNum := int32(wire >> 3)
  9522  		wireType := int(wire & 0x7)
  9523  		if wireType == 4 {
  9524  			return fmt.Errorf("proto: PrepareRequest: wiretype end group for non-group")
  9525  		}
  9526  		if fieldNum <= 0 {
  9527  			return fmt.Errorf("proto: PrepareRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9528  		}
  9529  		switch fieldNum {
  9530  		case 1:
  9531  			if wireType != 2 {
  9532  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  9533  			}
  9534  			var msglen int
  9535  			for shift := uint(0); ; shift += 7 {
  9536  				if shift >= 64 {
  9537  					return ErrIntOverflow
  9538  				}
  9539  				if iNdEx >= l {
  9540  					return io.ErrUnexpectedEOF
  9541  				}
  9542  				b := dAtA[iNdEx]
  9543  				iNdEx++
  9544  				msglen |= int(b&0x7F) << shift
  9545  				if b < 0x80 {
  9546  					break
  9547  				}
  9548  			}
  9549  			if msglen < 0 {
  9550  				return ErrInvalidLength
  9551  			}
  9552  			postIndex := iNdEx + msglen
  9553  			if postIndex < 0 {
  9554  				return ErrInvalidLength
  9555  			}
  9556  			if postIndex > l {
  9557  				return io.ErrUnexpectedEOF
  9558  			}
  9559  			if m.EffectiveCallerId == nil {
  9560  				m.EffectiveCallerId = &vtrpc.CallerID{}
  9561  			}
  9562  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9563  				return err
  9564  			}
  9565  			iNdEx = postIndex
  9566  		case 2:
  9567  			if wireType != 2 {
  9568  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  9569  			}
  9570  			var msglen int
  9571  			for shift := uint(0); ; shift += 7 {
  9572  				if shift >= 64 {
  9573  					return ErrIntOverflow
  9574  				}
  9575  				if iNdEx >= l {
  9576  					return io.ErrUnexpectedEOF
  9577  				}
  9578  				b := dAtA[iNdEx]
  9579  				iNdEx++
  9580  				msglen |= int(b&0x7F) << shift
  9581  				if b < 0x80 {
  9582  					break
  9583  				}
  9584  			}
  9585  			if msglen < 0 {
  9586  				return ErrInvalidLength
  9587  			}
  9588  			postIndex := iNdEx + msglen
  9589  			if postIndex < 0 {
  9590  				return ErrInvalidLength
  9591  			}
  9592  			if postIndex > l {
  9593  				return io.ErrUnexpectedEOF
  9594  			}
  9595  			if m.ImmediateCallerId == nil {
  9596  				m.ImmediateCallerId = &VTGateCallerID{}
  9597  			}
  9598  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9599  				return err
  9600  			}
  9601  			iNdEx = postIndex
  9602  		case 3:
  9603  			if wireType != 2 {
  9604  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  9605  			}
  9606  			var msglen int
  9607  			for shift := uint(0); ; shift += 7 {
  9608  				if shift >= 64 {
  9609  					return ErrIntOverflow
  9610  				}
  9611  				if iNdEx >= l {
  9612  					return io.ErrUnexpectedEOF
  9613  				}
  9614  				b := dAtA[iNdEx]
  9615  				iNdEx++
  9616  				msglen |= int(b&0x7F) << shift
  9617  				if b < 0x80 {
  9618  					break
  9619  				}
  9620  			}
  9621  			if msglen < 0 {
  9622  				return ErrInvalidLength
  9623  			}
  9624  			postIndex := iNdEx + msglen
  9625  			if postIndex < 0 {
  9626  				return ErrInvalidLength
  9627  			}
  9628  			if postIndex > l {
  9629  				return io.ErrUnexpectedEOF
  9630  			}
  9631  			if m.Target == nil {
  9632  				m.Target = &Target{}
  9633  			}
  9634  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9635  				return err
  9636  			}
  9637  			iNdEx = postIndex
  9638  		case 4:
  9639  			if wireType != 0 {
  9640  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
  9641  			}
  9642  			m.TransactionId = 0
  9643  			for shift := uint(0); ; shift += 7 {
  9644  				if shift >= 64 {
  9645  					return ErrIntOverflow
  9646  				}
  9647  				if iNdEx >= l {
  9648  					return io.ErrUnexpectedEOF
  9649  				}
  9650  				b := dAtA[iNdEx]
  9651  				iNdEx++
  9652  				m.TransactionId |= int64(b&0x7F) << shift
  9653  				if b < 0x80 {
  9654  					break
  9655  				}
  9656  			}
  9657  		case 5:
  9658  			if wireType != 2 {
  9659  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
  9660  			}
  9661  			var stringLen uint64
  9662  			for shift := uint(0); ; shift += 7 {
  9663  				if shift >= 64 {
  9664  					return ErrIntOverflow
  9665  				}
  9666  				if iNdEx >= l {
  9667  					return io.ErrUnexpectedEOF
  9668  				}
  9669  				b := dAtA[iNdEx]
  9670  				iNdEx++
  9671  				stringLen |= uint64(b&0x7F) << shift
  9672  				if b < 0x80 {
  9673  					break
  9674  				}
  9675  			}
  9676  			intStringLen := int(stringLen)
  9677  			if intStringLen < 0 {
  9678  				return ErrInvalidLength
  9679  			}
  9680  			postIndex := iNdEx + intStringLen
  9681  			if postIndex < 0 {
  9682  				return ErrInvalidLength
  9683  			}
  9684  			if postIndex > l {
  9685  				return io.ErrUnexpectedEOF
  9686  			}
  9687  			m.Dtid = string(dAtA[iNdEx:postIndex])
  9688  			iNdEx = postIndex
  9689  		default:
  9690  			iNdEx = preIndex
  9691  			skippy, err := skip(dAtA[iNdEx:])
  9692  			if err != nil {
  9693  				return err
  9694  			}
  9695  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9696  				return ErrInvalidLength
  9697  			}
  9698  			if (iNdEx + skippy) > l {
  9699  				return io.ErrUnexpectedEOF
  9700  			}
  9701  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9702  			iNdEx += skippy
  9703  		}
  9704  	}
  9705  
  9706  	if iNdEx > l {
  9707  		return io.ErrUnexpectedEOF
  9708  	}
  9709  	return nil
  9710  }
  9711  func (m *PrepareResponse) UnmarshalVT(dAtA []byte) error {
  9712  	l := len(dAtA)
  9713  	iNdEx := 0
  9714  	for iNdEx < l {
  9715  		preIndex := iNdEx
  9716  		var wire uint64
  9717  		for shift := uint(0); ; shift += 7 {
  9718  			if shift >= 64 {
  9719  				return ErrIntOverflow
  9720  			}
  9721  			if iNdEx >= l {
  9722  				return io.ErrUnexpectedEOF
  9723  			}
  9724  			b := dAtA[iNdEx]
  9725  			iNdEx++
  9726  			wire |= uint64(b&0x7F) << shift
  9727  			if b < 0x80 {
  9728  				break
  9729  			}
  9730  		}
  9731  		fieldNum := int32(wire >> 3)
  9732  		wireType := int(wire & 0x7)
  9733  		if wireType == 4 {
  9734  			return fmt.Errorf("proto: PrepareResponse: wiretype end group for non-group")
  9735  		}
  9736  		if fieldNum <= 0 {
  9737  			return fmt.Errorf("proto: PrepareResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9738  		}
  9739  		switch fieldNum {
  9740  		default:
  9741  			iNdEx = preIndex
  9742  			skippy, err := skip(dAtA[iNdEx:])
  9743  			if err != nil {
  9744  				return err
  9745  			}
  9746  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9747  				return ErrInvalidLength
  9748  			}
  9749  			if (iNdEx + skippy) > l {
  9750  				return io.ErrUnexpectedEOF
  9751  			}
  9752  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9753  			iNdEx += skippy
  9754  		}
  9755  	}
  9756  
  9757  	if iNdEx > l {
  9758  		return io.ErrUnexpectedEOF
  9759  	}
  9760  	return nil
  9761  }
  9762  func (m *CommitPreparedRequest) UnmarshalVT(dAtA []byte) error {
  9763  	l := len(dAtA)
  9764  	iNdEx := 0
  9765  	for iNdEx < l {
  9766  		preIndex := iNdEx
  9767  		var wire uint64
  9768  		for shift := uint(0); ; shift += 7 {
  9769  			if shift >= 64 {
  9770  				return ErrIntOverflow
  9771  			}
  9772  			if iNdEx >= l {
  9773  				return io.ErrUnexpectedEOF
  9774  			}
  9775  			b := dAtA[iNdEx]
  9776  			iNdEx++
  9777  			wire |= uint64(b&0x7F) << shift
  9778  			if b < 0x80 {
  9779  				break
  9780  			}
  9781  		}
  9782  		fieldNum := int32(wire >> 3)
  9783  		wireType := int(wire & 0x7)
  9784  		if wireType == 4 {
  9785  			return fmt.Errorf("proto: CommitPreparedRequest: wiretype end group for non-group")
  9786  		}
  9787  		if fieldNum <= 0 {
  9788  			return fmt.Errorf("proto: CommitPreparedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9789  		}
  9790  		switch fieldNum {
  9791  		case 1:
  9792  			if wireType != 2 {
  9793  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
  9794  			}
  9795  			var msglen int
  9796  			for shift := uint(0); ; shift += 7 {
  9797  				if shift >= 64 {
  9798  					return ErrIntOverflow
  9799  				}
  9800  				if iNdEx >= l {
  9801  					return io.ErrUnexpectedEOF
  9802  				}
  9803  				b := dAtA[iNdEx]
  9804  				iNdEx++
  9805  				msglen |= int(b&0x7F) << shift
  9806  				if b < 0x80 {
  9807  					break
  9808  				}
  9809  			}
  9810  			if msglen < 0 {
  9811  				return ErrInvalidLength
  9812  			}
  9813  			postIndex := iNdEx + msglen
  9814  			if postIndex < 0 {
  9815  				return ErrInvalidLength
  9816  			}
  9817  			if postIndex > l {
  9818  				return io.ErrUnexpectedEOF
  9819  			}
  9820  			if m.EffectiveCallerId == nil {
  9821  				m.EffectiveCallerId = &vtrpc.CallerID{}
  9822  			}
  9823  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9824  				return err
  9825  			}
  9826  			iNdEx = postIndex
  9827  		case 2:
  9828  			if wireType != 2 {
  9829  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
  9830  			}
  9831  			var msglen int
  9832  			for shift := uint(0); ; shift += 7 {
  9833  				if shift >= 64 {
  9834  					return ErrIntOverflow
  9835  				}
  9836  				if iNdEx >= l {
  9837  					return io.ErrUnexpectedEOF
  9838  				}
  9839  				b := dAtA[iNdEx]
  9840  				iNdEx++
  9841  				msglen |= int(b&0x7F) << shift
  9842  				if b < 0x80 {
  9843  					break
  9844  				}
  9845  			}
  9846  			if msglen < 0 {
  9847  				return ErrInvalidLength
  9848  			}
  9849  			postIndex := iNdEx + msglen
  9850  			if postIndex < 0 {
  9851  				return ErrInvalidLength
  9852  			}
  9853  			if postIndex > l {
  9854  				return io.ErrUnexpectedEOF
  9855  			}
  9856  			if m.ImmediateCallerId == nil {
  9857  				m.ImmediateCallerId = &VTGateCallerID{}
  9858  			}
  9859  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9860  				return err
  9861  			}
  9862  			iNdEx = postIndex
  9863  		case 3:
  9864  			if wireType != 2 {
  9865  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  9866  			}
  9867  			var msglen int
  9868  			for shift := uint(0); ; shift += 7 {
  9869  				if shift >= 64 {
  9870  					return ErrIntOverflow
  9871  				}
  9872  				if iNdEx >= l {
  9873  					return io.ErrUnexpectedEOF
  9874  				}
  9875  				b := dAtA[iNdEx]
  9876  				iNdEx++
  9877  				msglen |= int(b&0x7F) << shift
  9878  				if b < 0x80 {
  9879  					break
  9880  				}
  9881  			}
  9882  			if msglen < 0 {
  9883  				return ErrInvalidLength
  9884  			}
  9885  			postIndex := iNdEx + msglen
  9886  			if postIndex < 0 {
  9887  				return ErrInvalidLength
  9888  			}
  9889  			if postIndex > l {
  9890  				return io.ErrUnexpectedEOF
  9891  			}
  9892  			if m.Target == nil {
  9893  				m.Target = &Target{}
  9894  			}
  9895  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9896  				return err
  9897  			}
  9898  			iNdEx = postIndex
  9899  		case 4:
  9900  			if wireType != 2 {
  9901  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
  9902  			}
  9903  			var stringLen uint64
  9904  			for shift := uint(0); ; shift += 7 {
  9905  				if shift >= 64 {
  9906  					return ErrIntOverflow
  9907  				}
  9908  				if iNdEx >= l {
  9909  					return io.ErrUnexpectedEOF
  9910  				}
  9911  				b := dAtA[iNdEx]
  9912  				iNdEx++
  9913  				stringLen |= uint64(b&0x7F) << shift
  9914  				if b < 0x80 {
  9915  					break
  9916  				}
  9917  			}
  9918  			intStringLen := int(stringLen)
  9919  			if intStringLen < 0 {
  9920  				return ErrInvalidLength
  9921  			}
  9922  			postIndex := iNdEx + intStringLen
  9923  			if postIndex < 0 {
  9924  				return ErrInvalidLength
  9925  			}
  9926  			if postIndex > l {
  9927  				return io.ErrUnexpectedEOF
  9928  			}
  9929  			m.Dtid = string(dAtA[iNdEx:postIndex])
  9930  			iNdEx = postIndex
  9931  		default:
  9932  			iNdEx = preIndex
  9933  			skippy, err := skip(dAtA[iNdEx:])
  9934  			if err != nil {
  9935  				return err
  9936  			}
  9937  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9938  				return ErrInvalidLength
  9939  			}
  9940  			if (iNdEx + skippy) > l {
  9941  				return io.ErrUnexpectedEOF
  9942  			}
  9943  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9944  			iNdEx += skippy
  9945  		}
  9946  	}
  9947  
  9948  	if iNdEx > l {
  9949  		return io.ErrUnexpectedEOF
  9950  	}
  9951  	return nil
  9952  }
  9953  func (m *CommitPreparedResponse) UnmarshalVT(dAtA []byte) error {
  9954  	l := len(dAtA)
  9955  	iNdEx := 0
  9956  	for iNdEx < l {
  9957  		preIndex := iNdEx
  9958  		var wire uint64
  9959  		for shift := uint(0); ; shift += 7 {
  9960  			if shift >= 64 {
  9961  				return ErrIntOverflow
  9962  			}
  9963  			if iNdEx >= l {
  9964  				return io.ErrUnexpectedEOF
  9965  			}
  9966  			b := dAtA[iNdEx]
  9967  			iNdEx++
  9968  			wire |= uint64(b&0x7F) << shift
  9969  			if b < 0x80 {
  9970  				break
  9971  			}
  9972  		}
  9973  		fieldNum := int32(wire >> 3)
  9974  		wireType := int(wire & 0x7)
  9975  		if wireType == 4 {
  9976  			return fmt.Errorf("proto: CommitPreparedResponse: wiretype end group for non-group")
  9977  		}
  9978  		if fieldNum <= 0 {
  9979  			return fmt.Errorf("proto: CommitPreparedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9980  		}
  9981  		switch fieldNum {
  9982  		default:
  9983  			iNdEx = preIndex
  9984  			skippy, err := skip(dAtA[iNdEx:])
  9985  			if err != nil {
  9986  				return err
  9987  			}
  9988  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9989  				return ErrInvalidLength
  9990  			}
  9991  			if (iNdEx + skippy) > l {
  9992  				return io.ErrUnexpectedEOF
  9993  			}
  9994  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9995  			iNdEx += skippy
  9996  		}
  9997  	}
  9998  
  9999  	if iNdEx > l {
 10000  		return io.ErrUnexpectedEOF
 10001  	}
 10002  	return nil
 10003  }
 10004  func (m *RollbackPreparedRequest) UnmarshalVT(dAtA []byte) error {
 10005  	l := len(dAtA)
 10006  	iNdEx := 0
 10007  	for iNdEx < l {
 10008  		preIndex := iNdEx
 10009  		var wire uint64
 10010  		for shift := uint(0); ; shift += 7 {
 10011  			if shift >= 64 {
 10012  				return ErrIntOverflow
 10013  			}
 10014  			if iNdEx >= l {
 10015  				return io.ErrUnexpectedEOF
 10016  			}
 10017  			b := dAtA[iNdEx]
 10018  			iNdEx++
 10019  			wire |= uint64(b&0x7F) << shift
 10020  			if b < 0x80 {
 10021  				break
 10022  			}
 10023  		}
 10024  		fieldNum := int32(wire >> 3)
 10025  		wireType := int(wire & 0x7)
 10026  		if wireType == 4 {
 10027  			return fmt.Errorf("proto: RollbackPreparedRequest: wiretype end group for non-group")
 10028  		}
 10029  		if fieldNum <= 0 {
 10030  			return fmt.Errorf("proto: RollbackPreparedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10031  		}
 10032  		switch fieldNum {
 10033  		case 1:
 10034  			if wireType != 2 {
 10035  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 10036  			}
 10037  			var msglen int
 10038  			for shift := uint(0); ; shift += 7 {
 10039  				if shift >= 64 {
 10040  					return ErrIntOverflow
 10041  				}
 10042  				if iNdEx >= l {
 10043  					return io.ErrUnexpectedEOF
 10044  				}
 10045  				b := dAtA[iNdEx]
 10046  				iNdEx++
 10047  				msglen |= int(b&0x7F) << shift
 10048  				if b < 0x80 {
 10049  					break
 10050  				}
 10051  			}
 10052  			if msglen < 0 {
 10053  				return ErrInvalidLength
 10054  			}
 10055  			postIndex := iNdEx + msglen
 10056  			if postIndex < 0 {
 10057  				return ErrInvalidLength
 10058  			}
 10059  			if postIndex > l {
 10060  				return io.ErrUnexpectedEOF
 10061  			}
 10062  			if m.EffectiveCallerId == nil {
 10063  				m.EffectiveCallerId = &vtrpc.CallerID{}
 10064  			}
 10065  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10066  				return err
 10067  			}
 10068  			iNdEx = postIndex
 10069  		case 2:
 10070  			if wireType != 2 {
 10071  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 10072  			}
 10073  			var msglen int
 10074  			for shift := uint(0); ; shift += 7 {
 10075  				if shift >= 64 {
 10076  					return ErrIntOverflow
 10077  				}
 10078  				if iNdEx >= l {
 10079  					return io.ErrUnexpectedEOF
 10080  				}
 10081  				b := dAtA[iNdEx]
 10082  				iNdEx++
 10083  				msglen |= int(b&0x7F) << shift
 10084  				if b < 0x80 {
 10085  					break
 10086  				}
 10087  			}
 10088  			if msglen < 0 {
 10089  				return ErrInvalidLength
 10090  			}
 10091  			postIndex := iNdEx + msglen
 10092  			if postIndex < 0 {
 10093  				return ErrInvalidLength
 10094  			}
 10095  			if postIndex > l {
 10096  				return io.ErrUnexpectedEOF
 10097  			}
 10098  			if m.ImmediateCallerId == nil {
 10099  				m.ImmediateCallerId = &VTGateCallerID{}
 10100  			}
 10101  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10102  				return err
 10103  			}
 10104  			iNdEx = postIndex
 10105  		case 3:
 10106  			if wireType != 2 {
 10107  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 10108  			}
 10109  			var msglen int
 10110  			for shift := uint(0); ; shift += 7 {
 10111  				if shift >= 64 {
 10112  					return ErrIntOverflow
 10113  				}
 10114  				if iNdEx >= l {
 10115  					return io.ErrUnexpectedEOF
 10116  				}
 10117  				b := dAtA[iNdEx]
 10118  				iNdEx++
 10119  				msglen |= int(b&0x7F) << shift
 10120  				if b < 0x80 {
 10121  					break
 10122  				}
 10123  			}
 10124  			if msglen < 0 {
 10125  				return ErrInvalidLength
 10126  			}
 10127  			postIndex := iNdEx + msglen
 10128  			if postIndex < 0 {
 10129  				return ErrInvalidLength
 10130  			}
 10131  			if postIndex > l {
 10132  				return io.ErrUnexpectedEOF
 10133  			}
 10134  			if m.Target == nil {
 10135  				m.Target = &Target{}
 10136  			}
 10137  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10138  				return err
 10139  			}
 10140  			iNdEx = postIndex
 10141  		case 4:
 10142  			if wireType != 0 {
 10143  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 10144  			}
 10145  			m.TransactionId = 0
 10146  			for shift := uint(0); ; shift += 7 {
 10147  				if shift >= 64 {
 10148  					return ErrIntOverflow
 10149  				}
 10150  				if iNdEx >= l {
 10151  					return io.ErrUnexpectedEOF
 10152  				}
 10153  				b := dAtA[iNdEx]
 10154  				iNdEx++
 10155  				m.TransactionId |= int64(b&0x7F) << shift
 10156  				if b < 0x80 {
 10157  					break
 10158  				}
 10159  			}
 10160  		case 5:
 10161  			if wireType != 2 {
 10162  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 10163  			}
 10164  			var stringLen uint64
 10165  			for shift := uint(0); ; shift += 7 {
 10166  				if shift >= 64 {
 10167  					return ErrIntOverflow
 10168  				}
 10169  				if iNdEx >= l {
 10170  					return io.ErrUnexpectedEOF
 10171  				}
 10172  				b := dAtA[iNdEx]
 10173  				iNdEx++
 10174  				stringLen |= uint64(b&0x7F) << shift
 10175  				if b < 0x80 {
 10176  					break
 10177  				}
 10178  			}
 10179  			intStringLen := int(stringLen)
 10180  			if intStringLen < 0 {
 10181  				return ErrInvalidLength
 10182  			}
 10183  			postIndex := iNdEx + intStringLen
 10184  			if postIndex < 0 {
 10185  				return ErrInvalidLength
 10186  			}
 10187  			if postIndex > l {
 10188  				return io.ErrUnexpectedEOF
 10189  			}
 10190  			m.Dtid = string(dAtA[iNdEx:postIndex])
 10191  			iNdEx = postIndex
 10192  		default:
 10193  			iNdEx = preIndex
 10194  			skippy, err := skip(dAtA[iNdEx:])
 10195  			if err != nil {
 10196  				return err
 10197  			}
 10198  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10199  				return ErrInvalidLength
 10200  			}
 10201  			if (iNdEx + skippy) > l {
 10202  				return io.ErrUnexpectedEOF
 10203  			}
 10204  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10205  			iNdEx += skippy
 10206  		}
 10207  	}
 10208  
 10209  	if iNdEx > l {
 10210  		return io.ErrUnexpectedEOF
 10211  	}
 10212  	return nil
 10213  }
 10214  func (m *RollbackPreparedResponse) UnmarshalVT(dAtA []byte) error {
 10215  	l := len(dAtA)
 10216  	iNdEx := 0
 10217  	for iNdEx < l {
 10218  		preIndex := iNdEx
 10219  		var wire uint64
 10220  		for shift := uint(0); ; shift += 7 {
 10221  			if shift >= 64 {
 10222  				return ErrIntOverflow
 10223  			}
 10224  			if iNdEx >= l {
 10225  				return io.ErrUnexpectedEOF
 10226  			}
 10227  			b := dAtA[iNdEx]
 10228  			iNdEx++
 10229  			wire |= uint64(b&0x7F) << shift
 10230  			if b < 0x80 {
 10231  				break
 10232  			}
 10233  		}
 10234  		fieldNum := int32(wire >> 3)
 10235  		wireType := int(wire & 0x7)
 10236  		if wireType == 4 {
 10237  			return fmt.Errorf("proto: RollbackPreparedResponse: wiretype end group for non-group")
 10238  		}
 10239  		if fieldNum <= 0 {
 10240  			return fmt.Errorf("proto: RollbackPreparedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10241  		}
 10242  		switch fieldNum {
 10243  		default:
 10244  			iNdEx = preIndex
 10245  			skippy, err := skip(dAtA[iNdEx:])
 10246  			if err != nil {
 10247  				return err
 10248  			}
 10249  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10250  				return ErrInvalidLength
 10251  			}
 10252  			if (iNdEx + skippy) > l {
 10253  				return io.ErrUnexpectedEOF
 10254  			}
 10255  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10256  			iNdEx += skippy
 10257  		}
 10258  	}
 10259  
 10260  	if iNdEx > l {
 10261  		return io.ErrUnexpectedEOF
 10262  	}
 10263  	return nil
 10264  }
 10265  func (m *CreateTransactionRequest) UnmarshalVT(dAtA []byte) error {
 10266  	l := len(dAtA)
 10267  	iNdEx := 0
 10268  	for iNdEx < l {
 10269  		preIndex := iNdEx
 10270  		var wire uint64
 10271  		for shift := uint(0); ; shift += 7 {
 10272  			if shift >= 64 {
 10273  				return ErrIntOverflow
 10274  			}
 10275  			if iNdEx >= l {
 10276  				return io.ErrUnexpectedEOF
 10277  			}
 10278  			b := dAtA[iNdEx]
 10279  			iNdEx++
 10280  			wire |= uint64(b&0x7F) << shift
 10281  			if b < 0x80 {
 10282  				break
 10283  			}
 10284  		}
 10285  		fieldNum := int32(wire >> 3)
 10286  		wireType := int(wire & 0x7)
 10287  		if wireType == 4 {
 10288  			return fmt.Errorf("proto: CreateTransactionRequest: wiretype end group for non-group")
 10289  		}
 10290  		if fieldNum <= 0 {
 10291  			return fmt.Errorf("proto: CreateTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10292  		}
 10293  		switch fieldNum {
 10294  		case 1:
 10295  			if wireType != 2 {
 10296  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 10297  			}
 10298  			var msglen int
 10299  			for shift := uint(0); ; shift += 7 {
 10300  				if shift >= 64 {
 10301  					return ErrIntOverflow
 10302  				}
 10303  				if iNdEx >= l {
 10304  					return io.ErrUnexpectedEOF
 10305  				}
 10306  				b := dAtA[iNdEx]
 10307  				iNdEx++
 10308  				msglen |= int(b&0x7F) << shift
 10309  				if b < 0x80 {
 10310  					break
 10311  				}
 10312  			}
 10313  			if msglen < 0 {
 10314  				return ErrInvalidLength
 10315  			}
 10316  			postIndex := iNdEx + msglen
 10317  			if postIndex < 0 {
 10318  				return ErrInvalidLength
 10319  			}
 10320  			if postIndex > l {
 10321  				return io.ErrUnexpectedEOF
 10322  			}
 10323  			if m.EffectiveCallerId == nil {
 10324  				m.EffectiveCallerId = &vtrpc.CallerID{}
 10325  			}
 10326  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10327  				return err
 10328  			}
 10329  			iNdEx = postIndex
 10330  		case 2:
 10331  			if wireType != 2 {
 10332  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 10333  			}
 10334  			var msglen int
 10335  			for shift := uint(0); ; shift += 7 {
 10336  				if shift >= 64 {
 10337  					return ErrIntOverflow
 10338  				}
 10339  				if iNdEx >= l {
 10340  					return io.ErrUnexpectedEOF
 10341  				}
 10342  				b := dAtA[iNdEx]
 10343  				iNdEx++
 10344  				msglen |= int(b&0x7F) << shift
 10345  				if b < 0x80 {
 10346  					break
 10347  				}
 10348  			}
 10349  			if msglen < 0 {
 10350  				return ErrInvalidLength
 10351  			}
 10352  			postIndex := iNdEx + msglen
 10353  			if postIndex < 0 {
 10354  				return ErrInvalidLength
 10355  			}
 10356  			if postIndex > l {
 10357  				return io.ErrUnexpectedEOF
 10358  			}
 10359  			if m.ImmediateCallerId == nil {
 10360  				m.ImmediateCallerId = &VTGateCallerID{}
 10361  			}
 10362  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10363  				return err
 10364  			}
 10365  			iNdEx = postIndex
 10366  		case 3:
 10367  			if wireType != 2 {
 10368  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 10369  			}
 10370  			var msglen int
 10371  			for shift := uint(0); ; shift += 7 {
 10372  				if shift >= 64 {
 10373  					return ErrIntOverflow
 10374  				}
 10375  				if iNdEx >= l {
 10376  					return io.ErrUnexpectedEOF
 10377  				}
 10378  				b := dAtA[iNdEx]
 10379  				iNdEx++
 10380  				msglen |= int(b&0x7F) << shift
 10381  				if b < 0x80 {
 10382  					break
 10383  				}
 10384  			}
 10385  			if msglen < 0 {
 10386  				return ErrInvalidLength
 10387  			}
 10388  			postIndex := iNdEx + msglen
 10389  			if postIndex < 0 {
 10390  				return ErrInvalidLength
 10391  			}
 10392  			if postIndex > l {
 10393  				return io.ErrUnexpectedEOF
 10394  			}
 10395  			if m.Target == nil {
 10396  				m.Target = &Target{}
 10397  			}
 10398  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10399  				return err
 10400  			}
 10401  			iNdEx = postIndex
 10402  		case 4:
 10403  			if wireType != 2 {
 10404  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 10405  			}
 10406  			var stringLen uint64
 10407  			for shift := uint(0); ; shift += 7 {
 10408  				if shift >= 64 {
 10409  					return ErrIntOverflow
 10410  				}
 10411  				if iNdEx >= l {
 10412  					return io.ErrUnexpectedEOF
 10413  				}
 10414  				b := dAtA[iNdEx]
 10415  				iNdEx++
 10416  				stringLen |= uint64(b&0x7F) << shift
 10417  				if b < 0x80 {
 10418  					break
 10419  				}
 10420  			}
 10421  			intStringLen := int(stringLen)
 10422  			if intStringLen < 0 {
 10423  				return ErrInvalidLength
 10424  			}
 10425  			postIndex := iNdEx + intStringLen
 10426  			if postIndex < 0 {
 10427  				return ErrInvalidLength
 10428  			}
 10429  			if postIndex > l {
 10430  				return io.ErrUnexpectedEOF
 10431  			}
 10432  			m.Dtid = string(dAtA[iNdEx:postIndex])
 10433  			iNdEx = postIndex
 10434  		case 5:
 10435  			if wireType != 2 {
 10436  				return fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType)
 10437  			}
 10438  			var msglen int
 10439  			for shift := uint(0); ; shift += 7 {
 10440  				if shift >= 64 {
 10441  					return ErrIntOverflow
 10442  				}
 10443  				if iNdEx >= l {
 10444  					return io.ErrUnexpectedEOF
 10445  				}
 10446  				b := dAtA[iNdEx]
 10447  				iNdEx++
 10448  				msglen |= int(b&0x7F) << shift
 10449  				if b < 0x80 {
 10450  					break
 10451  				}
 10452  			}
 10453  			if msglen < 0 {
 10454  				return ErrInvalidLength
 10455  			}
 10456  			postIndex := iNdEx + msglen
 10457  			if postIndex < 0 {
 10458  				return ErrInvalidLength
 10459  			}
 10460  			if postIndex > l {
 10461  				return io.ErrUnexpectedEOF
 10462  			}
 10463  			m.Participants = append(m.Participants, &Target{})
 10464  			if err := m.Participants[len(m.Participants)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10465  				return err
 10466  			}
 10467  			iNdEx = postIndex
 10468  		default:
 10469  			iNdEx = preIndex
 10470  			skippy, err := skip(dAtA[iNdEx:])
 10471  			if err != nil {
 10472  				return err
 10473  			}
 10474  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10475  				return ErrInvalidLength
 10476  			}
 10477  			if (iNdEx + skippy) > l {
 10478  				return io.ErrUnexpectedEOF
 10479  			}
 10480  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10481  			iNdEx += skippy
 10482  		}
 10483  	}
 10484  
 10485  	if iNdEx > l {
 10486  		return io.ErrUnexpectedEOF
 10487  	}
 10488  	return nil
 10489  }
 10490  func (m *CreateTransactionResponse) UnmarshalVT(dAtA []byte) error {
 10491  	l := len(dAtA)
 10492  	iNdEx := 0
 10493  	for iNdEx < l {
 10494  		preIndex := iNdEx
 10495  		var wire uint64
 10496  		for shift := uint(0); ; shift += 7 {
 10497  			if shift >= 64 {
 10498  				return ErrIntOverflow
 10499  			}
 10500  			if iNdEx >= l {
 10501  				return io.ErrUnexpectedEOF
 10502  			}
 10503  			b := dAtA[iNdEx]
 10504  			iNdEx++
 10505  			wire |= uint64(b&0x7F) << shift
 10506  			if b < 0x80 {
 10507  				break
 10508  			}
 10509  		}
 10510  		fieldNum := int32(wire >> 3)
 10511  		wireType := int(wire & 0x7)
 10512  		if wireType == 4 {
 10513  			return fmt.Errorf("proto: CreateTransactionResponse: wiretype end group for non-group")
 10514  		}
 10515  		if fieldNum <= 0 {
 10516  			return fmt.Errorf("proto: CreateTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10517  		}
 10518  		switch fieldNum {
 10519  		default:
 10520  			iNdEx = preIndex
 10521  			skippy, err := skip(dAtA[iNdEx:])
 10522  			if err != nil {
 10523  				return err
 10524  			}
 10525  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10526  				return ErrInvalidLength
 10527  			}
 10528  			if (iNdEx + skippy) > l {
 10529  				return io.ErrUnexpectedEOF
 10530  			}
 10531  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10532  			iNdEx += skippy
 10533  		}
 10534  	}
 10535  
 10536  	if iNdEx > l {
 10537  		return io.ErrUnexpectedEOF
 10538  	}
 10539  	return nil
 10540  }
 10541  func (m *StartCommitRequest) UnmarshalVT(dAtA []byte) error {
 10542  	l := len(dAtA)
 10543  	iNdEx := 0
 10544  	for iNdEx < l {
 10545  		preIndex := iNdEx
 10546  		var wire uint64
 10547  		for shift := uint(0); ; shift += 7 {
 10548  			if shift >= 64 {
 10549  				return ErrIntOverflow
 10550  			}
 10551  			if iNdEx >= l {
 10552  				return io.ErrUnexpectedEOF
 10553  			}
 10554  			b := dAtA[iNdEx]
 10555  			iNdEx++
 10556  			wire |= uint64(b&0x7F) << shift
 10557  			if b < 0x80 {
 10558  				break
 10559  			}
 10560  		}
 10561  		fieldNum := int32(wire >> 3)
 10562  		wireType := int(wire & 0x7)
 10563  		if wireType == 4 {
 10564  			return fmt.Errorf("proto: StartCommitRequest: wiretype end group for non-group")
 10565  		}
 10566  		if fieldNum <= 0 {
 10567  			return fmt.Errorf("proto: StartCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10568  		}
 10569  		switch fieldNum {
 10570  		case 1:
 10571  			if wireType != 2 {
 10572  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 10573  			}
 10574  			var msglen int
 10575  			for shift := uint(0); ; shift += 7 {
 10576  				if shift >= 64 {
 10577  					return ErrIntOverflow
 10578  				}
 10579  				if iNdEx >= l {
 10580  					return io.ErrUnexpectedEOF
 10581  				}
 10582  				b := dAtA[iNdEx]
 10583  				iNdEx++
 10584  				msglen |= int(b&0x7F) << shift
 10585  				if b < 0x80 {
 10586  					break
 10587  				}
 10588  			}
 10589  			if msglen < 0 {
 10590  				return ErrInvalidLength
 10591  			}
 10592  			postIndex := iNdEx + msglen
 10593  			if postIndex < 0 {
 10594  				return ErrInvalidLength
 10595  			}
 10596  			if postIndex > l {
 10597  				return io.ErrUnexpectedEOF
 10598  			}
 10599  			if m.EffectiveCallerId == nil {
 10600  				m.EffectiveCallerId = &vtrpc.CallerID{}
 10601  			}
 10602  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10603  				return err
 10604  			}
 10605  			iNdEx = postIndex
 10606  		case 2:
 10607  			if wireType != 2 {
 10608  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 10609  			}
 10610  			var msglen int
 10611  			for shift := uint(0); ; shift += 7 {
 10612  				if shift >= 64 {
 10613  					return ErrIntOverflow
 10614  				}
 10615  				if iNdEx >= l {
 10616  					return io.ErrUnexpectedEOF
 10617  				}
 10618  				b := dAtA[iNdEx]
 10619  				iNdEx++
 10620  				msglen |= int(b&0x7F) << shift
 10621  				if b < 0x80 {
 10622  					break
 10623  				}
 10624  			}
 10625  			if msglen < 0 {
 10626  				return ErrInvalidLength
 10627  			}
 10628  			postIndex := iNdEx + msglen
 10629  			if postIndex < 0 {
 10630  				return ErrInvalidLength
 10631  			}
 10632  			if postIndex > l {
 10633  				return io.ErrUnexpectedEOF
 10634  			}
 10635  			if m.ImmediateCallerId == nil {
 10636  				m.ImmediateCallerId = &VTGateCallerID{}
 10637  			}
 10638  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10639  				return err
 10640  			}
 10641  			iNdEx = postIndex
 10642  		case 3:
 10643  			if wireType != 2 {
 10644  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 10645  			}
 10646  			var msglen int
 10647  			for shift := uint(0); ; shift += 7 {
 10648  				if shift >= 64 {
 10649  					return ErrIntOverflow
 10650  				}
 10651  				if iNdEx >= l {
 10652  					return io.ErrUnexpectedEOF
 10653  				}
 10654  				b := dAtA[iNdEx]
 10655  				iNdEx++
 10656  				msglen |= int(b&0x7F) << shift
 10657  				if b < 0x80 {
 10658  					break
 10659  				}
 10660  			}
 10661  			if msglen < 0 {
 10662  				return ErrInvalidLength
 10663  			}
 10664  			postIndex := iNdEx + msglen
 10665  			if postIndex < 0 {
 10666  				return ErrInvalidLength
 10667  			}
 10668  			if postIndex > l {
 10669  				return io.ErrUnexpectedEOF
 10670  			}
 10671  			if m.Target == nil {
 10672  				m.Target = &Target{}
 10673  			}
 10674  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10675  				return err
 10676  			}
 10677  			iNdEx = postIndex
 10678  		case 4:
 10679  			if wireType != 0 {
 10680  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 10681  			}
 10682  			m.TransactionId = 0
 10683  			for shift := uint(0); ; shift += 7 {
 10684  				if shift >= 64 {
 10685  					return ErrIntOverflow
 10686  				}
 10687  				if iNdEx >= l {
 10688  					return io.ErrUnexpectedEOF
 10689  				}
 10690  				b := dAtA[iNdEx]
 10691  				iNdEx++
 10692  				m.TransactionId |= int64(b&0x7F) << shift
 10693  				if b < 0x80 {
 10694  					break
 10695  				}
 10696  			}
 10697  		case 5:
 10698  			if wireType != 2 {
 10699  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 10700  			}
 10701  			var stringLen uint64
 10702  			for shift := uint(0); ; shift += 7 {
 10703  				if shift >= 64 {
 10704  					return ErrIntOverflow
 10705  				}
 10706  				if iNdEx >= l {
 10707  					return io.ErrUnexpectedEOF
 10708  				}
 10709  				b := dAtA[iNdEx]
 10710  				iNdEx++
 10711  				stringLen |= uint64(b&0x7F) << shift
 10712  				if b < 0x80 {
 10713  					break
 10714  				}
 10715  			}
 10716  			intStringLen := int(stringLen)
 10717  			if intStringLen < 0 {
 10718  				return ErrInvalidLength
 10719  			}
 10720  			postIndex := iNdEx + intStringLen
 10721  			if postIndex < 0 {
 10722  				return ErrInvalidLength
 10723  			}
 10724  			if postIndex > l {
 10725  				return io.ErrUnexpectedEOF
 10726  			}
 10727  			m.Dtid = string(dAtA[iNdEx:postIndex])
 10728  			iNdEx = postIndex
 10729  		default:
 10730  			iNdEx = preIndex
 10731  			skippy, err := skip(dAtA[iNdEx:])
 10732  			if err != nil {
 10733  				return err
 10734  			}
 10735  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10736  				return ErrInvalidLength
 10737  			}
 10738  			if (iNdEx + skippy) > l {
 10739  				return io.ErrUnexpectedEOF
 10740  			}
 10741  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10742  			iNdEx += skippy
 10743  		}
 10744  	}
 10745  
 10746  	if iNdEx > l {
 10747  		return io.ErrUnexpectedEOF
 10748  	}
 10749  	return nil
 10750  }
 10751  func (m *StartCommitResponse) UnmarshalVT(dAtA []byte) error {
 10752  	l := len(dAtA)
 10753  	iNdEx := 0
 10754  	for iNdEx < l {
 10755  		preIndex := iNdEx
 10756  		var wire uint64
 10757  		for shift := uint(0); ; shift += 7 {
 10758  			if shift >= 64 {
 10759  				return ErrIntOverflow
 10760  			}
 10761  			if iNdEx >= l {
 10762  				return io.ErrUnexpectedEOF
 10763  			}
 10764  			b := dAtA[iNdEx]
 10765  			iNdEx++
 10766  			wire |= uint64(b&0x7F) << shift
 10767  			if b < 0x80 {
 10768  				break
 10769  			}
 10770  		}
 10771  		fieldNum := int32(wire >> 3)
 10772  		wireType := int(wire & 0x7)
 10773  		if wireType == 4 {
 10774  			return fmt.Errorf("proto: StartCommitResponse: wiretype end group for non-group")
 10775  		}
 10776  		if fieldNum <= 0 {
 10777  			return fmt.Errorf("proto: StartCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10778  		}
 10779  		switch fieldNum {
 10780  		default:
 10781  			iNdEx = preIndex
 10782  			skippy, err := skip(dAtA[iNdEx:])
 10783  			if err != nil {
 10784  				return err
 10785  			}
 10786  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10787  				return ErrInvalidLength
 10788  			}
 10789  			if (iNdEx + skippy) > l {
 10790  				return io.ErrUnexpectedEOF
 10791  			}
 10792  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10793  			iNdEx += skippy
 10794  		}
 10795  	}
 10796  
 10797  	if iNdEx > l {
 10798  		return io.ErrUnexpectedEOF
 10799  	}
 10800  	return nil
 10801  }
 10802  func (m *SetRollbackRequest) UnmarshalVT(dAtA []byte) error {
 10803  	l := len(dAtA)
 10804  	iNdEx := 0
 10805  	for iNdEx < l {
 10806  		preIndex := iNdEx
 10807  		var wire uint64
 10808  		for shift := uint(0); ; shift += 7 {
 10809  			if shift >= 64 {
 10810  				return ErrIntOverflow
 10811  			}
 10812  			if iNdEx >= l {
 10813  				return io.ErrUnexpectedEOF
 10814  			}
 10815  			b := dAtA[iNdEx]
 10816  			iNdEx++
 10817  			wire |= uint64(b&0x7F) << shift
 10818  			if b < 0x80 {
 10819  				break
 10820  			}
 10821  		}
 10822  		fieldNum := int32(wire >> 3)
 10823  		wireType := int(wire & 0x7)
 10824  		if wireType == 4 {
 10825  			return fmt.Errorf("proto: SetRollbackRequest: wiretype end group for non-group")
 10826  		}
 10827  		if fieldNum <= 0 {
 10828  			return fmt.Errorf("proto: SetRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10829  		}
 10830  		switch fieldNum {
 10831  		case 1:
 10832  			if wireType != 2 {
 10833  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 10834  			}
 10835  			var msglen int
 10836  			for shift := uint(0); ; shift += 7 {
 10837  				if shift >= 64 {
 10838  					return ErrIntOverflow
 10839  				}
 10840  				if iNdEx >= l {
 10841  					return io.ErrUnexpectedEOF
 10842  				}
 10843  				b := dAtA[iNdEx]
 10844  				iNdEx++
 10845  				msglen |= int(b&0x7F) << shift
 10846  				if b < 0x80 {
 10847  					break
 10848  				}
 10849  			}
 10850  			if msglen < 0 {
 10851  				return ErrInvalidLength
 10852  			}
 10853  			postIndex := iNdEx + msglen
 10854  			if postIndex < 0 {
 10855  				return ErrInvalidLength
 10856  			}
 10857  			if postIndex > l {
 10858  				return io.ErrUnexpectedEOF
 10859  			}
 10860  			if m.EffectiveCallerId == nil {
 10861  				m.EffectiveCallerId = &vtrpc.CallerID{}
 10862  			}
 10863  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10864  				return err
 10865  			}
 10866  			iNdEx = postIndex
 10867  		case 2:
 10868  			if wireType != 2 {
 10869  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 10870  			}
 10871  			var msglen int
 10872  			for shift := uint(0); ; shift += 7 {
 10873  				if shift >= 64 {
 10874  					return ErrIntOverflow
 10875  				}
 10876  				if iNdEx >= l {
 10877  					return io.ErrUnexpectedEOF
 10878  				}
 10879  				b := dAtA[iNdEx]
 10880  				iNdEx++
 10881  				msglen |= int(b&0x7F) << shift
 10882  				if b < 0x80 {
 10883  					break
 10884  				}
 10885  			}
 10886  			if msglen < 0 {
 10887  				return ErrInvalidLength
 10888  			}
 10889  			postIndex := iNdEx + msglen
 10890  			if postIndex < 0 {
 10891  				return ErrInvalidLength
 10892  			}
 10893  			if postIndex > l {
 10894  				return io.ErrUnexpectedEOF
 10895  			}
 10896  			if m.ImmediateCallerId == nil {
 10897  				m.ImmediateCallerId = &VTGateCallerID{}
 10898  			}
 10899  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10900  				return err
 10901  			}
 10902  			iNdEx = postIndex
 10903  		case 3:
 10904  			if wireType != 2 {
 10905  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 10906  			}
 10907  			var msglen int
 10908  			for shift := uint(0); ; shift += 7 {
 10909  				if shift >= 64 {
 10910  					return ErrIntOverflow
 10911  				}
 10912  				if iNdEx >= l {
 10913  					return io.ErrUnexpectedEOF
 10914  				}
 10915  				b := dAtA[iNdEx]
 10916  				iNdEx++
 10917  				msglen |= int(b&0x7F) << shift
 10918  				if b < 0x80 {
 10919  					break
 10920  				}
 10921  			}
 10922  			if msglen < 0 {
 10923  				return ErrInvalidLength
 10924  			}
 10925  			postIndex := iNdEx + msglen
 10926  			if postIndex < 0 {
 10927  				return ErrInvalidLength
 10928  			}
 10929  			if postIndex > l {
 10930  				return io.ErrUnexpectedEOF
 10931  			}
 10932  			if m.Target == nil {
 10933  				m.Target = &Target{}
 10934  			}
 10935  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10936  				return err
 10937  			}
 10938  			iNdEx = postIndex
 10939  		case 4:
 10940  			if wireType != 0 {
 10941  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 10942  			}
 10943  			m.TransactionId = 0
 10944  			for shift := uint(0); ; shift += 7 {
 10945  				if shift >= 64 {
 10946  					return ErrIntOverflow
 10947  				}
 10948  				if iNdEx >= l {
 10949  					return io.ErrUnexpectedEOF
 10950  				}
 10951  				b := dAtA[iNdEx]
 10952  				iNdEx++
 10953  				m.TransactionId |= int64(b&0x7F) << shift
 10954  				if b < 0x80 {
 10955  					break
 10956  				}
 10957  			}
 10958  		case 5:
 10959  			if wireType != 2 {
 10960  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 10961  			}
 10962  			var stringLen uint64
 10963  			for shift := uint(0); ; shift += 7 {
 10964  				if shift >= 64 {
 10965  					return ErrIntOverflow
 10966  				}
 10967  				if iNdEx >= l {
 10968  					return io.ErrUnexpectedEOF
 10969  				}
 10970  				b := dAtA[iNdEx]
 10971  				iNdEx++
 10972  				stringLen |= uint64(b&0x7F) << shift
 10973  				if b < 0x80 {
 10974  					break
 10975  				}
 10976  			}
 10977  			intStringLen := int(stringLen)
 10978  			if intStringLen < 0 {
 10979  				return ErrInvalidLength
 10980  			}
 10981  			postIndex := iNdEx + intStringLen
 10982  			if postIndex < 0 {
 10983  				return ErrInvalidLength
 10984  			}
 10985  			if postIndex > l {
 10986  				return io.ErrUnexpectedEOF
 10987  			}
 10988  			m.Dtid = string(dAtA[iNdEx:postIndex])
 10989  			iNdEx = postIndex
 10990  		default:
 10991  			iNdEx = preIndex
 10992  			skippy, err := skip(dAtA[iNdEx:])
 10993  			if err != nil {
 10994  				return err
 10995  			}
 10996  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10997  				return ErrInvalidLength
 10998  			}
 10999  			if (iNdEx + skippy) > l {
 11000  				return io.ErrUnexpectedEOF
 11001  			}
 11002  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11003  			iNdEx += skippy
 11004  		}
 11005  	}
 11006  
 11007  	if iNdEx > l {
 11008  		return io.ErrUnexpectedEOF
 11009  	}
 11010  	return nil
 11011  }
 11012  func (m *SetRollbackResponse) UnmarshalVT(dAtA []byte) error {
 11013  	l := len(dAtA)
 11014  	iNdEx := 0
 11015  	for iNdEx < l {
 11016  		preIndex := iNdEx
 11017  		var wire uint64
 11018  		for shift := uint(0); ; shift += 7 {
 11019  			if shift >= 64 {
 11020  				return ErrIntOverflow
 11021  			}
 11022  			if iNdEx >= l {
 11023  				return io.ErrUnexpectedEOF
 11024  			}
 11025  			b := dAtA[iNdEx]
 11026  			iNdEx++
 11027  			wire |= uint64(b&0x7F) << shift
 11028  			if b < 0x80 {
 11029  				break
 11030  			}
 11031  		}
 11032  		fieldNum := int32(wire >> 3)
 11033  		wireType := int(wire & 0x7)
 11034  		if wireType == 4 {
 11035  			return fmt.Errorf("proto: SetRollbackResponse: wiretype end group for non-group")
 11036  		}
 11037  		if fieldNum <= 0 {
 11038  			return fmt.Errorf("proto: SetRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11039  		}
 11040  		switch fieldNum {
 11041  		default:
 11042  			iNdEx = preIndex
 11043  			skippy, err := skip(dAtA[iNdEx:])
 11044  			if err != nil {
 11045  				return err
 11046  			}
 11047  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11048  				return ErrInvalidLength
 11049  			}
 11050  			if (iNdEx + skippy) > l {
 11051  				return io.ErrUnexpectedEOF
 11052  			}
 11053  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11054  			iNdEx += skippy
 11055  		}
 11056  	}
 11057  
 11058  	if iNdEx > l {
 11059  		return io.ErrUnexpectedEOF
 11060  	}
 11061  	return nil
 11062  }
 11063  func (m *ConcludeTransactionRequest) UnmarshalVT(dAtA []byte) error {
 11064  	l := len(dAtA)
 11065  	iNdEx := 0
 11066  	for iNdEx < l {
 11067  		preIndex := iNdEx
 11068  		var wire uint64
 11069  		for shift := uint(0); ; shift += 7 {
 11070  			if shift >= 64 {
 11071  				return ErrIntOverflow
 11072  			}
 11073  			if iNdEx >= l {
 11074  				return io.ErrUnexpectedEOF
 11075  			}
 11076  			b := dAtA[iNdEx]
 11077  			iNdEx++
 11078  			wire |= uint64(b&0x7F) << shift
 11079  			if b < 0x80 {
 11080  				break
 11081  			}
 11082  		}
 11083  		fieldNum := int32(wire >> 3)
 11084  		wireType := int(wire & 0x7)
 11085  		if wireType == 4 {
 11086  			return fmt.Errorf("proto: ConcludeTransactionRequest: wiretype end group for non-group")
 11087  		}
 11088  		if fieldNum <= 0 {
 11089  			return fmt.Errorf("proto: ConcludeTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11090  		}
 11091  		switch fieldNum {
 11092  		case 1:
 11093  			if wireType != 2 {
 11094  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 11095  			}
 11096  			var msglen int
 11097  			for shift := uint(0); ; shift += 7 {
 11098  				if shift >= 64 {
 11099  					return ErrIntOverflow
 11100  				}
 11101  				if iNdEx >= l {
 11102  					return io.ErrUnexpectedEOF
 11103  				}
 11104  				b := dAtA[iNdEx]
 11105  				iNdEx++
 11106  				msglen |= int(b&0x7F) << shift
 11107  				if b < 0x80 {
 11108  					break
 11109  				}
 11110  			}
 11111  			if msglen < 0 {
 11112  				return ErrInvalidLength
 11113  			}
 11114  			postIndex := iNdEx + msglen
 11115  			if postIndex < 0 {
 11116  				return ErrInvalidLength
 11117  			}
 11118  			if postIndex > l {
 11119  				return io.ErrUnexpectedEOF
 11120  			}
 11121  			if m.EffectiveCallerId == nil {
 11122  				m.EffectiveCallerId = &vtrpc.CallerID{}
 11123  			}
 11124  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11125  				return err
 11126  			}
 11127  			iNdEx = postIndex
 11128  		case 2:
 11129  			if wireType != 2 {
 11130  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 11131  			}
 11132  			var msglen int
 11133  			for shift := uint(0); ; shift += 7 {
 11134  				if shift >= 64 {
 11135  					return ErrIntOverflow
 11136  				}
 11137  				if iNdEx >= l {
 11138  					return io.ErrUnexpectedEOF
 11139  				}
 11140  				b := dAtA[iNdEx]
 11141  				iNdEx++
 11142  				msglen |= int(b&0x7F) << shift
 11143  				if b < 0x80 {
 11144  					break
 11145  				}
 11146  			}
 11147  			if msglen < 0 {
 11148  				return ErrInvalidLength
 11149  			}
 11150  			postIndex := iNdEx + msglen
 11151  			if postIndex < 0 {
 11152  				return ErrInvalidLength
 11153  			}
 11154  			if postIndex > l {
 11155  				return io.ErrUnexpectedEOF
 11156  			}
 11157  			if m.ImmediateCallerId == nil {
 11158  				m.ImmediateCallerId = &VTGateCallerID{}
 11159  			}
 11160  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11161  				return err
 11162  			}
 11163  			iNdEx = postIndex
 11164  		case 3:
 11165  			if wireType != 2 {
 11166  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 11167  			}
 11168  			var msglen int
 11169  			for shift := uint(0); ; shift += 7 {
 11170  				if shift >= 64 {
 11171  					return ErrIntOverflow
 11172  				}
 11173  				if iNdEx >= l {
 11174  					return io.ErrUnexpectedEOF
 11175  				}
 11176  				b := dAtA[iNdEx]
 11177  				iNdEx++
 11178  				msglen |= int(b&0x7F) << shift
 11179  				if b < 0x80 {
 11180  					break
 11181  				}
 11182  			}
 11183  			if msglen < 0 {
 11184  				return ErrInvalidLength
 11185  			}
 11186  			postIndex := iNdEx + msglen
 11187  			if postIndex < 0 {
 11188  				return ErrInvalidLength
 11189  			}
 11190  			if postIndex > l {
 11191  				return io.ErrUnexpectedEOF
 11192  			}
 11193  			if m.Target == nil {
 11194  				m.Target = &Target{}
 11195  			}
 11196  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11197  				return err
 11198  			}
 11199  			iNdEx = postIndex
 11200  		case 4:
 11201  			if wireType != 2 {
 11202  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 11203  			}
 11204  			var stringLen uint64
 11205  			for shift := uint(0); ; shift += 7 {
 11206  				if shift >= 64 {
 11207  					return ErrIntOverflow
 11208  				}
 11209  				if iNdEx >= l {
 11210  					return io.ErrUnexpectedEOF
 11211  				}
 11212  				b := dAtA[iNdEx]
 11213  				iNdEx++
 11214  				stringLen |= uint64(b&0x7F) << shift
 11215  				if b < 0x80 {
 11216  					break
 11217  				}
 11218  			}
 11219  			intStringLen := int(stringLen)
 11220  			if intStringLen < 0 {
 11221  				return ErrInvalidLength
 11222  			}
 11223  			postIndex := iNdEx + intStringLen
 11224  			if postIndex < 0 {
 11225  				return ErrInvalidLength
 11226  			}
 11227  			if postIndex > l {
 11228  				return io.ErrUnexpectedEOF
 11229  			}
 11230  			m.Dtid = string(dAtA[iNdEx:postIndex])
 11231  			iNdEx = postIndex
 11232  		default:
 11233  			iNdEx = preIndex
 11234  			skippy, err := skip(dAtA[iNdEx:])
 11235  			if err != nil {
 11236  				return err
 11237  			}
 11238  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11239  				return ErrInvalidLength
 11240  			}
 11241  			if (iNdEx + skippy) > l {
 11242  				return io.ErrUnexpectedEOF
 11243  			}
 11244  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11245  			iNdEx += skippy
 11246  		}
 11247  	}
 11248  
 11249  	if iNdEx > l {
 11250  		return io.ErrUnexpectedEOF
 11251  	}
 11252  	return nil
 11253  }
 11254  func (m *ConcludeTransactionResponse) UnmarshalVT(dAtA []byte) error {
 11255  	l := len(dAtA)
 11256  	iNdEx := 0
 11257  	for iNdEx < l {
 11258  		preIndex := iNdEx
 11259  		var wire uint64
 11260  		for shift := uint(0); ; shift += 7 {
 11261  			if shift >= 64 {
 11262  				return ErrIntOverflow
 11263  			}
 11264  			if iNdEx >= l {
 11265  				return io.ErrUnexpectedEOF
 11266  			}
 11267  			b := dAtA[iNdEx]
 11268  			iNdEx++
 11269  			wire |= uint64(b&0x7F) << shift
 11270  			if b < 0x80 {
 11271  				break
 11272  			}
 11273  		}
 11274  		fieldNum := int32(wire >> 3)
 11275  		wireType := int(wire & 0x7)
 11276  		if wireType == 4 {
 11277  			return fmt.Errorf("proto: ConcludeTransactionResponse: wiretype end group for non-group")
 11278  		}
 11279  		if fieldNum <= 0 {
 11280  			return fmt.Errorf("proto: ConcludeTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11281  		}
 11282  		switch fieldNum {
 11283  		default:
 11284  			iNdEx = preIndex
 11285  			skippy, err := skip(dAtA[iNdEx:])
 11286  			if err != nil {
 11287  				return err
 11288  			}
 11289  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11290  				return ErrInvalidLength
 11291  			}
 11292  			if (iNdEx + skippy) > l {
 11293  				return io.ErrUnexpectedEOF
 11294  			}
 11295  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11296  			iNdEx += skippy
 11297  		}
 11298  	}
 11299  
 11300  	if iNdEx > l {
 11301  		return io.ErrUnexpectedEOF
 11302  	}
 11303  	return nil
 11304  }
 11305  func (m *ReadTransactionRequest) UnmarshalVT(dAtA []byte) error {
 11306  	l := len(dAtA)
 11307  	iNdEx := 0
 11308  	for iNdEx < l {
 11309  		preIndex := iNdEx
 11310  		var wire uint64
 11311  		for shift := uint(0); ; shift += 7 {
 11312  			if shift >= 64 {
 11313  				return ErrIntOverflow
 11314  			}
 11315  			if iNdEx >= l {
 11316  				return io.ErrUnexpectedEOF
 11317  			}
 11318  			b := dAtA[iNdEx]
 11319  			iNdEx++
 11320  			wire |= uint64(b&0x7F) << shift
 11321  			if b < 0x80 {
 11322  				break
 11323  			}
 11324  		}
 11325  		fieldNum := int32(wire >> 3)
 11326  		wireType := int(wire & 0x7)
 11327  		if wireType == 4 {
 11328  			return fmt.Errorf("proto: ReadTransactionRequest: wiretype end group for non-group")
 11329  		}
 11330  		if fieldNum <= 0 {
 11331  			return fmt.Errorf("proto: ReadTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11332  		}
 11333  		switch fieldNum {
 11334  		case 1:
 11335  			if wireType != 2 {
 11336  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 11337  			}
 11338  			var msglen int
 11339  			for shift := uint(0); ; shift += 7 {
 11340  				if shift >= 64 {
 11341  					return ErrIntOverflow
 11342  				}
 11343  				if iNdEx >= l {
 11344  					return io.ErrUnexpectedEOF
 11345  				}
 11346  				b := dAtA[iNdEx]
 11347  				iNdEx++
 11348  				msglen |= int(b&0x7F) << shift
 11349  				if b < 0x80 {
 11350  					break
 11351  				}
 11352  			}
 11353  			if msglen < 0 {
 11354  				return ErrInvalidLength
 11355  			}
 11356  			postIndex := iNdEx + msglen
 11357  			if postIndex < 0 {
 11358  				return ErrInvalidLength
 11359  			}
 11360  			if postIndex > l {
 11361  				return io.ErrUnexpectedEOF
 11362  			}
 11363  			if m.EffectiveCallerId == nil {
 11364  				m.EffectiveCallerId = &vtrpc.CallerID{}
 11365  			}
 11366  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11367  				return err
 11368  			}
 11369  			iNdEx = postIndex
 11370  		case 2:
 11371  			if wireType != 2 {
 11372  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 11373  			}
 11374  			var msglen int
 11375  			for shift := uint(0); ; shift += 7 {
 11376  				if shift >= 64 {
 11377  					return ErrIntOverflow
 11378  				}
 11379  				if iNdEx >= l {
 11380  					return io.ErrUnexpectedEOF
 11381  				}
 11382  				b := dAtA[iNdEx]
 11383  				iNdEx++
 11384  				msglen |= int(b&0x7F) << shift
 11385  				if b < 0x80 {
 11386  					break
 11387  				}
 11388  			}
 11389  			if msglen < 0 {
 11390  				return ErrInvalidLength
 11391  			}
 11392  			postIndex := iNdEx + msglen
 11393  			if postIndex < 0 {
 11394  				return ErrInvalidLength
 11395  			}
 11396  			if postIndex > l {
 11397  				return io.ErrUnexpectedEOF
 11398  			}
 11399  			if m.ImmediateCallerId == nil {
 11400  				m.ImmediateCallerId = &VTGateCallerID{}
 11401  			}
 11402  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11403  				return err
 11404  			}
 11405  			iNdEx = postIndex
 11406  		case 3:
 11407  			if wireType != 2 {
 11408  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 11409  			}
 11410  			var msglen int
 11411  			for shift := uint(0); ; shift += 7 {
 11412  				if shift >= 64 {
 11413  					return ErrIntOverflow
 11414  				}
 11415  				if iNdEx >= l {
 11416  					return io.ErrUnexpectedEOF
 11417  				}
 11418  				b := dAtA[iNdEx]
 11419  				iNdEx++
 11420  				msglen |= int(b&0x7F) << shift
 11421  				if b < 0x80 {
 11422  					break
 11423  				}
 11424  			}
 11425  			if msglen < 0 {
 11426  				return ErrInvalidLength
 11427  			}
 11428  			postIndex := iNdEx + msglen
 11429  			if postIndex < 0 {
 11430  				return ErrInvalidLength
 11431  			}
 11432  			if postIndex > l {
 11433  				return io.ErrUnexpectedEOF
 11434  			}
 11435  			if m.Target == nil {
 11436  				m.Target = &Target{}
 11437  			}
 11438  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11439  				return err
 11440  			}
 11441  			iNdEx = postIndex
 11442  		case 4:
 11443  			if wireType != 2 {
 11444  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 11445  			}
 11446  			var stringLen uint64
 11447  			for shift := uint(0); ; shift += 7 {
 11448  				if shift >= 64 {
 11449  					return ErrIntOverflow
 11450  				}
 11451  				if iNdEx >= l {
 11452  					return io.ErrUnexpectedEOF
 11453  				}
 11454  				b := dAtA[iNdEx]
 11455  				iNdEx++
 11456  				stringLen |= uint64(b&0x7F) << shift
 11457  				if b < 0x80 {
 11458  					break
 11459  				}
 11460  			}
 11461  			intStringLen := int(stringLen)
 11462  			if intStringLen < 0 {
 11463  				return ErrInvalidLength
 11464  			}
 11465  			postIndex := iNdEx + intStringLen
 11466  			if postIndex < 0 {
 11467  				return ErrInvalidLength
 11468  			}
 11469  			if postIndex > l {
 11470  				return io.ErrUnexpectedEOF
 11471  			}
 11472  			m.Dtid = string(dAtA[iNdEx:postIndex])
 11473  			iNdEx = postIndex
 11474  		default:
 11475  			iNdEx = preIndex
 11476  			skippy, err := skip(dAtA[iNdEx:])
 11477  			if err != nil {
 11478  				return err
 11479  			}
 11480  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11481  				return ErrInvalidLength
 11482  			}
 11483  			if (iNdEx + skippy) > l {
 11484  				return io.ErrUnexpectedEOF
 11485  			}
 11486  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11487  			iNdEx += skippy
 11488  		}
 11489  	}
 11490  
 11491  	if iNdEx > l {
 11492  		return io.ErrUnexpectedEOF
 11493  	}
 11494  	return nil
 11495  }
 11496  func (m *ReadTransactionResponse) UnmarshalVT(dAtA []byte) error {
 11497  	l := len(dAtA)
 11498  	iNdEx := 0
 11499  	for iNdEx < l {
 11500  		preIndex := iNdEx
 11501  		var wire uint64
 11502  		for shift := uint(0); ; shift += 7 {
 11503  			if shift >= 64 {
 11504  				return ErrIntOverflow
 11505  			}
 11506  			if iNdEx >= l {
 11507  				return io.ErrUnexpectedEOF
 11508  			}
 11509  			b := dAtA[iNdEx]
 11510  			iNdEx++
 11511  			wire |= uint64(b&0x7F) << shift
 11512  			if b < 0x80 {
 11513  				break
 11514  			}
 11515  		}
 11516  		fieldNum := int32(wire >> 3)
 11517  		wireType := int(wire & 0x7)
 11518  		if wireType == 4 {
 11519  			return fmt.Errorf("proto: ReadTransactionResponse: wiretype end group for non-group")
 11520  		}
 11521  		if fieldNum <= 0 {
 11522  			return fmt.Errorf("proto: ReadTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11523  		}
 11524  		switch fieldNum {
 11525  		case 1:
 11526  			if wireType != 2 {
 11527  				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
 11528  			}
 11529  			var msglen int
 11530  			for shift := uint(0); ; shift += 7 {
 11531  				if shift >= 64 {
 11532  					return ErrIntOverflow
 11533  				}
 11534  				if iNdEx >= l {
 11535  					return io.ErrUnexpectedEOF
 11536  				}
 11537  				b := dAtA[iNdEx]
 11538  				iNdEx++
 11539  				msglen |= int(b&0x7F) << shift
 11540  				if b < 0x80 {
 11541  					break
 11542  				}
 11543  			}
 11544  			if msglen < 0 {
 11545  				return ErrInvalidLength
 11546  			}
 11547  			postIndex := iNdEx + msglen
 11548  			if postIndex < 0 {
 11549  				return ErrInvalidLength
 11550  			}
 11551  			if postIndex > l {
 11552  				return io.ErrUnexpectedEOF
 11553  			}
 11554  			if m.Metadata == nil {
 11555  				m.Metadata = &TransactionMetadata{}
 11556  			}
 11557  			if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11558  				return err
 11559  			}
 11560  			iNdEx = postIndex
 11561  		default:
 11562  			iNdEx = preIndex
 11563  			skippy, err := skip(dAtA[iNdEx:])
 11564  			if err != nil {
 11565  				return err
 11566  			}
 11567  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11568  				return ErrInvalidLength
 11569  			}
 11570  			if (iNdEx + skippy) > l {
 11571  				return io.ErrUnexpectedEOF
 11572  			}
 11573  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11574  			iNdEx += skippy
 11575  		}
 11576  	}
 11577  
 11578  	if iNdEx > l {
 11579  		return io.ErrUnexpectedEOF
 11580  	}
 11581  	return nil
 11582  }
 11583  func (m *BeginExecuteRequest) UnmarshalVT(dAtA []byte) error {
 11584  	l := len(dAtA)
 11585  	iNdEx := 0
 11586  	for iNdEx < l {
 11587  		preIndex := iNdEx
 11588  		var wire uint64
 11589  		for shift := uint(0); ; shift += 7 {
 11590  			if shift >= 64 {
 11591  				return ErrIntOverflow
 11592  			}
 11593  			if iNdEx >= l {
 11594  				return io.ErrUnexpectedEOF
 11595  			}
 11596  			b := dAtA[iNdEx]
 11597  			iNdEx++
 11598  			wire |= uint64(b&0x7F) << shift
 11599  			if b < 0x80 {
 11600  				break
 11601  			}
 11602  		}
 11603  		fieldNum := int32(wire >> 3)
 11604  		wireType := int(wire & 0x7)
 11605  		if wireType == 4 {
 11606  			return fmt.Errorf("proto: BeginExecuteRequest: wiretype end group for non-group")
 11607  		}
 11608  		if fieldNum <= 0 {
 11609  			return fmt.Errorf("proto: BeginExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11610  		}
 11611  		switch fieldNum {
 11612  		case 1:
 11613  			if wireType != 2 {
 11614  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 11615  			}
 11616  			var msglen int
 11617  			for shift := uint(0); ; shift += 7 {
 11618  				if shift >= 64 {
 11619  					return ErrIntOverflow
 11620  				}
 11621  				if iNdEx >= l {
 11622  					return io.ErrUnexpectedEOF
 11623  				}
 11624  				b := dAtA[iNdEx]
 11625  				iNdEx++
 11626  				msglen |= int(b&0x7F) << shift
 11627  				if b < 0x80 {
 11628  					break
 11629  				}
 11630  			}
 11631  			if msglen < 0 {
 11632  				return ErrInvalidLength
 11633  			}
 11634  			postIndex := iNdEx + msglen
 11635  			if postIndex < 0 {
 11636  				return ErrInvalidLength
 11637  			}
 11638  			if postIndex > l {
 11639  				return io.ErrUnexpectedEOF
 11640  			}
 11641  			if m.EffectiveCallerId == nil {
 11642  				m.EffectiveCallerId = &vtrpc.CallerID{}
 11643  			}
 11644  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11645  				return err
 11646  			}
 11647  			iNdEx = postIndex
 11648  		case 2:
 11649  			if wireType != 2 {
 11650  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 11651  			}
 11652  			var msglen int
 11653  			for shift := uint(0); ; shift += 7 {
 11654  				if shift >= 64 {
 11655  					return ErrIntOverflow
 11656  				}
 11657  				if iNdEx >= l {
 11658  					return io.ErrUnexpectedEOF
 11659  				}
 11660  				b := dAtA[iNdEx]
 11661  				iNdEx++
 11662  				msglen |= int(b&0x7F) << shift
 11663  				if b < 0x80 {
 11664  					break
 11665  				}
 11666  			}
 11667  			if msglen < 0 {
 11668  				return ErrInvalidLength
 11669  			}
 11670  			postIndex := iNdEx + msglen
 11671  			if postIndex < 0 {
 11672  				return ErrInvalidLength
 11673  			}
 11674  			if postIndex > l {
 11675  				return io.ErrUnexpectedEOF
 11676  			}
 11677  			if m.ImmediateCallerId == nil {
 11678  				m.ImmediateCallerId = &VTGateCallerID{}
 11679  			}
 11680  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11681  				return err
 11682  			}
 11683  			iNdEx = postIndex
 11684  		case 3:
 11685  			if wireType != 2 {
 11686  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 11687  			}
 11688  			var msglen int
 11689  			for shift := uint(0); ; shift += 7 {
 11690  				if shift >= 64 {
 11691  					return ErrIntOverflow
 11692  				}
 11693  				if iNdEx >= l {
 11694  					return io.ErrUnexpectedEOF
 11695  				}
 11696  				b := dAtA[iNdEx]
 11697  				iNdEx++
 11698  				msglen |= int(b&0x7F) << shift
 11699  				if b < 0x80 {
 11700  					break
 11701  				}
 11702  			}
 11703  			if msglen < 0 {
 11704  				return ErrInvalidLength
 11705  			}
 11706  			postIndex := iNdEx + msglen
 11707  			if postIndex < 0 {
 11708  				return ErrInvalidLength
 11709  			}
 11710  			if postIndex > l {
 11711  				return io.ErrUnexpectedEOF
 11712  			}
 11713  			if m.Target == nil {
 11714  				m.Target = &Target{}
 11715  			}
 11716  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11717  				return err
 11718  			}
 11719  			iNdEx = postIndex
 11720  		case 4:
 11721  			if wireType != 2 {
 11722  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 11723  			}
 11724  			var msglen int
 11725  			for shift := uint(0); ; shift += 7 {
 11726  				if shift >= 64 {
 11727  					return ErrIntOverflow
 11728  				}
 11729  				if iNdEx >= l {
 11730  					return io.ErrUnexpectedEOF
 11731  				}
 11732  				b := dAtA[iNdEx]
 11733  				iNdEx++
 11734  				msglen |= int(b&0x7F) << shift
 11735  				if b < 0x80 {
 11736  					break
 11737  				}
 11738  			}
 11739  			if msglen < 0 {
 11740  				return ErrInvalidLength
 11741  			}
 11742  			postIndex := iNdEx + msglen
 11743  			if postIndex < 0 {
 11744  				return ErrInvalidLength
 11745  			}
 11746  			if postIndex > l {
 11747  				return io.ErrUnexpectedEOF
 11748  			}
 11749  			if m.Query == nil {
 11750  				m.Query = &BoundQuery{}
 11751  			}
 11752  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11753  				return err
 11754  			}
 11755  			iNdEx = postIndex
 11756  		case 5:
 11757  			if wireType != 2 {
 11758  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 11759  			}
 11760  			var msglen int
 11761  			for shift := uint(0); ; shift += 7 {
 11762  				if shift >= 64 {
 11763  					return ErrIntOverflow
 11764  				}
 11765  				if iNdEx >= l {
 11766  					return io.ErrUnexpectedEOF
 11767  				}
 11768  				b := dAtA[iNdEx]
 11769  				iNdEx++
 11770  				msglen |= int(b&0x7F) << shift
 11771  				if b < 0x80 {
 11772  					break
 11773  				}
 11774  			}
 11775  			if msglen < 0 {
 11776  				return ErrInvalidLength
 11777  			}
 11778  			postIndex := iNdEx + msglen
 11779  			if postIndex < 0 {
 11780  				return ErrInvalidLength
 11781  			}
 11782  			if postIndex > l {
 11783  				return io.ErrUnexpectedEOF
 11784  			}
 11785  			if m.Options == nil {
 11786  				m.Options = &ExecuteOptions{}
 11787  			}
 11788  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11789  				return err
 11790  			}
 11791  			iNdEx = postIndex
 11792  		case 6:
 11793  			if wireType != 0 {
 11794  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 11795  			}
 11796  			m.ReservedId = 0
 11797  			for shift := uint(0); ; shift += 7 {
 11798  				if shift >= 64 {
 11799  					return ErrIntOverflow
 11800  				}
 11801  				if iNdEx >= l {
 11802  					return io.ErrUnexpectedEOF
 11803  				}
 11804  				b := dAtA[iNdEx]
 11805  				iNdEx++
 11806  				m.ReservedId |= int64(b&0x7F) << shift
 11807  				if b < 0x80 {
 11808  					break
 11809  				}
 11810  			}
 11811  		case 7:
 11812  			if wireType != 2 {
 11813  				return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType)
 11814  			}
 11815  			var stringLen uint64
 11816  			for shift := uint(0); ; shift += 7 {
 11817  				if shift >= 64 {
 11818  					return ErrIntOverflow
 11819  				}
 11820  				if iNdEx >= l {
 11821  					return io.ErrUnexpectedEOF
 11822  				}
 11823  				b := dAtA[iNdEx]
 11824  				iNdEx++
 11825  				stringLen |= uint64(b&0x7F) << shift
 11826  				if b < 0x80 {
 11827  					break
 11828  				}
 11829  			}
 11830  			intStringLen := int(stringLen)
 11831  			if intStringLen < 0 {
 11832  				return ErrInvalidLength
 11833  			}
 11834  			postIndex := iNdEx + intStringLen
 11835  			if postIndex < 0 {
 11836  				return ErrInvalidLength
 11837  			}
 11838  			if postIndex > l {
 11839  				return io.ErrUnexpectedEOF
 11840  			}
 11841  			m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex]))
 11842  			iNdEx = postIndex
 11843  		default:
 11844  			iNdEx = preIndex
 11845  			skippy, err := skip(dAtA[iNdEx:])
 11846  			if err != nil {
 11847  				return err
 11848  			}
 11849  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11850  				return ErrInvalidLength
 11851  			}
 11852  			if (iNdEx + skippy) > l {
 11853  				return io.ErrUnexpectedEOF
 11854  			}
 11855  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11856  			iNdEx += skippy
 11857  		}
 11858  	}
 11859  
 11860  	if iNdEx > l {
 11861  		return io.ErrUnexpectedEOF
 11862  	}
 11863  	return nil
 11864  }
 11865  func (m *BeginExecuteResponse) UnmarshalVT(dAtA []byte) error {
 11866  	l := len(dAtA)
 11867  	iNdEx := 0
 11868  	for iNdEx < l {
 11869  		preIndex := iNdEx
 11870  		var wire uint64
 11871  		for shift := uint(0); ; shift += 7 {
 11872  			if shift >= 64 {
 11873  				return ErrIntOverflow
 11874  			}
 11875  			if iNdEx >= l {
 11876  				return io.ErrUnexpectedEOF
 11877  			}
 11878  			b := dAtA[iNdEx]
 11879  			iNdEx++
 11880  			wire |= uint64(b&0x7F) << shift
 11881  			if b < 0x80 {
 11882  				break
 11883  			}
 11884  		}
 11885  		fieldNum := int32(wire >> 3)
 11886  		wireType := int(wire & 0x7)
 11887  		if wireType == 4 {
 11888  			return fmt.Errorf("proto: BeginExecuteResponse: wiretype end group for non-group")
 11889  		}
 11890  		if fieldNum <= 0 {
 11891  			return fmt.Errorf("proto: BeginExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11892  		}
 11893  		switch fieldNum {
 11894  		case 1:
 11895  			if wireType != 2 {
 11896  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 11897  			}
 11898  			var msglen int
 11899  			for shift := uint(0); ; shift += 7 {
 11900  				if shift >= 64 {
 11901  					return ErrIntOverflow
 11902  				}
 11903  				if iNdEx >= l {
 11904  					return io.ErrUnexpectedEOF
 11905  				}
 11906  				b := dAtA[iNdEx]
 11907  				iNdEx++
 11908  				msglen |= int(b&0x7F) << shift
 11909  				if b < 0x80 {
 11910  					break
 11911  				}
 11912  			}
 11913  			if msglen < 0 {
 11914  				return ErrInvalidLength
 11915  			}
 11916  			postIndex := iNdEx + msglen
 11917  			if postIndex < 0 {
 11918  				return ErrInvalidLength
 11919  			}
 11920  			if postIndex > l {
 11921  				return io.ErrUnexpectedEOF
 11922  			}
 11923  			if m.Error == nil {
 11924  				m.Error = &vtrpc.RPCError{}
 11925  			}
 11926  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11927  				return err
 11928  			}
 11929  			iNdEx = postIndex
 11930  		case 2:
 11931  			if wireType != 2 {
 11932  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 11933  			}
 11934  			var msglen int
 11935  			for shift := uint(0); ; shift += 7 {
 11936  				if shift >= 64 {
 11937  					return ErrIntOverflow
 11938  				}
 11939  				if iNdEx >= l {
 11940  					return io.ErrUnexpectedEOF
 11941  				}
 11942  				b := dAtA[iNdEx]
 11943  				iNdEx++
 11944  				msglen |= int(b&0x7F) << shift
 11945  				if b < 0x80 {
 11946  					break
 11947  				}
 11948  			}
 11949  			if msglen < 0 {
 11950  				return ErrInvalidLength
 11951  			}
 11952  			postIndex := iNdEx + msglen
 11953  			if postIndex < 0 {
 11954  				return ErrInvalidLength
 11955  			}
 11956  			if postIndex > l {
 11957  				return io.ErrUnexpectedEOF
 11958  			}
 11959  			if m.Result == nil {
 11960  				m.Result = &QueryResult{}
 11961  			}
 11962  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11963  				return err
 11964  			}
 11965  			iNdEx = postIndex
 11966  		case 3:
 11967  			if wireType != 0 {
 11968  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 11969  			}
 11970  			m.TransactionId = 0
 11971  			for shift := uint(0); ; shift += 7 {
 11972  				if shift >= 64 {
 11973  					return ErrIntOverflow
 11974  				}
 11975  				if iNdEx >= l {
 11976  					return io.ErrUnexpectedEOF
 11977  				}
 11978  				b := dAtA[iNdEx]
 11979  				iNdEx++
 11980  				m.TransactionId |= int64(b&0x7F) << shift
 11981  				if b < 0x80 {
 11982  					break
 11983  				}
 11984  			}
 11985  		case 4:
 11986  			if wireType != 2 {
 11987  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 11988  			}
 11989  			var msglen int
 11990  			for shift := uint(0); ; shift += 7 {
 11991  				if shift >= 64 {
 11992  					return ErrIntOverflow
 11993  				}
 11994  				if iNdEx >= l {
 11995  					return io.ErrUnexpectedEOF
 11996  				}
 11997  				b := dAtA[iNdEx]
 11998  				iNdEx++
 11999  				msglen |= int(b&0x7F) << shift
 12000  				if b < 0x80 {
 12001  					break
 12002  				}
 12003  			}
 12004  			if msglen < 0 {
 12005  				return ErrInvalidLength
 12006  			}
 12007  			postIndex := iNdEx + msglen
 12008  			if postIndex < 0 {
 12009  				return ErrInvalidLength
 12010  			}
 12011  			if postIndex > l {
 12012  				return io.ErrUnexpectedEOF
 12013  			}
 12014  			if m.TabletAlias == nil {
 12015  				m.TabletAlias = &topodata.TabletAlias{}
 12016  			}
 12017  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12018  				return err
 12019  			}
 12020  			iNdEx = postIndex
 12021  		default:
 12022  			iNdEx = preIndex
 12023  			skippy, err := skip(dAtA[iNdEx:])
 12024  			if err != nil {
 12025  				return err
 12026  			}
 12027  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12028  				return ErrInvalidLength
 12029  			}
 12030  			if (iNdEx + skippy) > l {
 12031  				return io.ErrUnexpectedEOF
 12032  			}
 12033  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12034  			iNdEx += skippy
 12035  		}
 12036  	}
 12037  
 12038  	if iNdEx > l {
 12039  		return io.ErrUnexpectedEOF
 12040  	}
 12041  	return nil
 12042  }
 12043  func (m *BeginStreamExecuteRequest) UnmarshalVT(dAtA []byte) error {
 12044  	l := len(dAtA)
 12045  	iNdEx := 0
 12046  	for iNdEx < l {
 12047  		preIndex := iNdEx
 12048  		var wire uint64
 12049  		for shift := uint(0); ; shift += 7 {
 12050  			if shift >= 64 {
 12051  				return ErrIntOverflow
 12052  			}
 12053  			if iNdEx >= l {
 12054  				return io.ErrUnexpectedEOF
 12055  			}
 12056  			b := dAtA[iNdEx]
 12057  			iNdEx++
 12058  			wire |= uint64(b&0x7F) << shift
 12059  			if b < 0x80 {
 12060  				break
 12061  			}
 12062  		}
 12063  		fieldNum := int32(wire >> 3)
 12064  		wireType := int(wire & 0x7)
 12065  		if wireType == 4 {
 12066  			return fmt.Errorf("proto: BeginStreamExecuteRequest: wiretype end group for non-group")
 12067  		}
 12068  		if fieldNum <= 0 {
 12069  			return fmt.Errorf("proto: BeginStreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12070  		}
 12071  		switch fieldNum {
 12072  		case 1:
 12073  			if wireType != 2 {
 12074  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 12075  			}
 12076  			var msglen int
 12077  			for shift := uint(0); ; shift += 7 {
 12078  				if shift >= 64 {
 12079  					return ErrIntOverflow
 12080  				}
 12081  				if iNdEx >= l {
 12082  					return io.ErrUnexpectedEOF
 12083  				}
 12084  				b := dAtA[iNdEx]
 12085  				iNdEx++
 12086  				msglen |= int(b&0x7F) << shift
 12087  				if b < 0x80 {
 12088  					break
 12089  				}
 12090  			}
 12091  			if msglen < 0 {
 12092  				return ErrInvalidLength
 12093  			}
 12094  			postIndex := iNdEx + msglen
 12095  			if postIndex < 0 {
 12096  				return ErrInvalidLength
 12097  			}
 12098  			if postIndex > l {
 12099  				return io.ErrUnexpectedEOF
 12100  			}
 12101  			if m.EffectiveCallerId == nil {
 12102  				m.EffectiveCallerId = &vtrpc.CallerID{}
 12103  			}
 12104  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12105  				return err
 12106  			}
 12107  			iNdEx = postIndex
 12108  		case 2:
 12109  			if wireType != 2 {
 12110  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 12111  			}
 12112  			var msglen int
 12113  			for shift := uint(0); ; shift += 7 {
 12114  				if shift >= 64 {
 12115  					return ErrIntOverflow
 12116  				}
 12117  				if iNdEx >= l {
 12118  					return io.ErrUnexpectedEOF
 12119  				}
 12120  				b := dAtA[iNdEx]
 12121  				iNdEx++
 12122  				msglen |= int(b&0x7F) << shift
 12123  				if b < 0x80 {
 12124  					break
 12125  				}
 12126  			}
 12127  			if msglen < 0 {
 12128  				return ErrInvalidLength
 12129  			}
 12130  			postIndex := iNdEx + msglen
 12131  			if postIndex < 0 {
 12132  				return ErrInvalidLength
 12133  			}
 12134  			if postIndex > l {
 12135  				return io.ErrUnexpectedEOF
 12136  			}
 12137  			if m.ImmediateCallerId == nil {
 12138  				m.ImmediateCallerId = &VTGateCallerID{}
 12139  			}
 12140  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12141  				return err
 12142  			}
 12143  			iNdEx = postIndex
 12144  		case 3:
 12145  			if wireType != 2 {
 12146  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 12147  			}
 12148  			var msglen int
 12149  			for shift := uint(0); ; shift += 7 {
 12150  				if shift >= 64 {
 12151  					return ErrIntOverflow
 12152  				}
 12153  				if iNdEx >= l {
 12154  					return io.ErrUnexpectedEOF
 12155  				}
 12156  				b := dAtA[iNdEx]
 12157  				iNdEx++
 12158  				msglen |= int(b&0x7F) << shift
 12159  				if b < 0x80 {
 12160  					break
 12161  				}
 12162  			}
 12163  			if msglen < 0 {
 12164  				return ErrInvalidLength
 12165  			}
 12166  			postIndex := iNdEx + msglen
 12167  			if postIndex < 0 {
 12168  				return ErrInvalidLength
 12169  			}
 12170  			if postIndex > l {
 12171  				return io.ErrUnexpectedEOF
 12172  			}
 12173  			if m.Target == nil {
 12174  				m.Target = &Target{}
 12175  			}
 12176  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12177  				return err
 12178  			}
 12179  			iNdEx = postIndex
 12180  		case 4:
 12181  			if wireType != 2 {
 12182  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 12183  			}
 12184  			var msglen int
 12185  			for shift := uint(0); ; shift += 7 {
 12186  				if shift >= 64 {
 12187  					return ErrIntOverflow
 12188  				}
 12189  				if iNdEx >= l {
 12190  					return io.ErrUnexpectedEOF
 12191  				}
 12192  				b := dAtA[iNdEx]
 12193  				iNdEx++
 12194  				msglen |= int(b&0x7F) << shift
 12195  				if b < 0x80 {
 12196  					break
 12197  				}
 12198  			}
 12199  			if msglen < 0 {
 12200  				return ErrInvalidLength
 12201  			}
 12202  			postIndex := iNdEx + msglen
 12203  			if postIndex < 0 {
 12204  				return ErrInvalidLength
 12205  			}
 12206  			if postIndex > l {
 12207  				return io.ErrUnexpectedEOF
 12208  			}
 12209  			if m.Query == nil {
 12210  				m.Query = &BoundQuery{}
 12211  			}
 12212  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12213  				return err
 12214  			}
 12215  			iNdEx = postIndex
 12216  		case 5:
 12217  			if wireType != 2 {
 12218  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 12219  			}
 12220  			var msglen int
 12221  			for shift := uint(0); ; shift += 7 {
 12222  				if shift >= 64 {
 12223  					return ErrIntOverflow
 12224  				}
 12225  				if iNdEx >= l {
 12226  					return io.ErrUnexpectedEOF
 12227  				}
 12228  				b := dAtA[iNdEx]
 12229  				iNdEx++
 12230  				msglen |= int(b&0x7F) << shift
 12231  				if b < 0x80 {
 12232  					break
 12233  				}
 12234  			}
 12235  			if msglen < 0 {
 12236  				return ErrInvalidLength
 12237  			}
 12238  			postIndex := iNdEx + msglen
 12239  			if postIndex < 0 {
 12240  				return ErrInvalidLength
 12241  			}
 12242  			if postIndex > l {
 12243  				return io.ErrUnexpectedEOF
 12244  			}
 12245  			if m.Options == nil {
 12246  				m.Options = &ExecuteOptions{}
 12247  			}
 12248  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12249  				return err
 12250  			}
 12251  			iNdEx = postIndex
 12252  		case 6:
 12253  			if wireType != 2 {
 12254  				return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType)
 12255  			}
 12256  			var stringLen uint64
 12257  			for shift := uint(0); ; shift += 7 {
 12258  				if shift >= 64 {
 12259  					return ErrIntOverflow
 12260  				}
 12261  				if iNdEx >= l {
 12262  					return io.ErrUnexpectedEOF
 12263  				}
 12264  				b := dAtA[iNdEx]
 12265  				iNdEx++
 12266  				stringLen |= uint64(b&0x7F) << shift
 12267  				if b < 0x80 {
 12268  					break
 12269  				}
 12270  			}
 12271  			intStringLen := int(stringLen)
 12272  			if intStringLen < 0 {
 12273  				return ErrInvalidLength
 12274  			}
 12275  			postIndex := iNdEx + intStringLen
 12276  			if postIndex < 0 {
 12277  				return ErrInvalidLength
 12278  			}
 12279  			if postIndex > l {
 12280  				return io.ErrUnexpectedEOF
 12281  			}
 12282  			m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex]))
 12283  			iNdEx = postIndex
 12284  		case 7:
 12285  			if wireType != 0 {
 12286  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 12287  			}
 12288  			m.ReservedId = 0
 12289  			for shift := uint(0); ; shift += 7 {
 12290  				if shift >= 64 {
 12291  					return ErrIntOverflow
 12292  				}
 12293  				if iNdEx >= l {
 12294  					return io.ErrUnexpectedEOF
 12295  				}
 12296  				b := dAtA[iNdEx]
 12297  				iNdEx++
 12298  				m.ReservedId |= int64(b&0x7F) << shift
 12299  				if b < 0x80 {
 12300  					break
 12301  				}
 12302  			}
 12303  		default:
 12304  			iNdEx = preIndex
 12305  			skippy, err := skip(dAtA[iNdEx:])
 12306  			if err != nil {
 12307  				return err
 12308  			}
 12309  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12310  				return ErrInvalidLength
 12311  			}
 12312  			if (iNdEx + skippy) > l {
 12313  				return io.ErrUnexpectedEOF
 12314  			}
 12315  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12316  			iNdEx += skippy
 12317  		}
 12318  	}
 12319  
 12320  	if iNdEx > l {
 12321  		return io.ErrUnexpectedEOF
 12322  	}
 12323  	return nil
 12324  }
 12325  func (m *BeginStreamExecuteResponse) UnmarshalVT(dAtA []byte) error {
 12326  	l := len(dAtA)
 12327  	iNdEx := 0
 12328  	for iNdEx < l {
 12329  		preIndex := iNdEx
 12330  		var wire uint64
 12331  		for shift := uint(0); ; shift += 7 {
 12332  			if shift >= 64 {
 12333  				return ErrIntOverflow
 12334  			}
 12335  			if iNdEx >= l {
 12336  				return io.ErrUnexpectedEOF
 12337  			}
 12338  			b := dAtA[iNdEx]
 12339  			iNdEx++
 12340  			wire |= uint64(b&0x7F) << shift
 12341  			if b < 0x80 {
 12342  				break
 12343  			}
 12344  		}
 12345  		fieldNum := int32(wire >> 3)
 12346  		wireType := int(wire & 0x7)
 12347  		if wireType == 4 {
 12348  			return fmt.Errorf("proto: BeginStreamExecuteResponse: wiretype end group for non-group")
 12349  		}
 12350  		if fieldNum <= 0 {
 12351  			return fmt.Errorf("proto: BeginStreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12352  		}
 12353  		switch fieldNum {
 12354  		case 1:
 12355  			if wireType != 2 {
 12356  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 12357  			}
 12358  			var msglen int
 12359  			for shift := uint(0); ; shift += 7 {
 12360  				if shift >= 64 {
 12361  					return ErrIntOverflow
 12362  				}
 12363  				if iNdEx >= l {
 12364  					return io.ErrUnexpectedEOF
 12365  				}
 12366  				b := dAtA[iNdEx]
 12367  				iNdEx++
 12368  				msglen |= int(b&0x7F) << shift
 12369  				if b < 0x80 {
 12370  					break
 12371  				}
 12372  			}
 12373  			if msglen < 0 {
 12374  				return ErrInvalidLength
 12375  			}
 12376  			postIndex := iNdEx + msglen
 12377  			if postIndex < 0 {
 12378  				return ErrInvalidLength
 12379  			}
 12380  			if postIndex > l {
 12381  				return io.ErrUnexpectedEOF
 12382  			}
 12383  			if m.Error == nil {
 12384  				m.Error = &vtrpc.RPCError{}
 12385  			}
 12386  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12387  				return err
 12388  			}
 12389  			iNdEx = postIndex
 12390  		case 2:
 12391  			if wireType != 2 {
 12392  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 12393  			}
 12394  			var msglen int
 12395  			for shift := uint(0); ; shift += 7 {
 12396  				if shift >= 64 {
 12397  					return ErrIntOverflow
 12398  				}
 12399  				if iNdEx >= l {
 12400  					return io.ErrUnexpectedEOF
 12401  				}
 12402  				b := dAtA[iNdEx]
 12403  				iNdEx++
 12404  				msglen |= int(b&0x7F) << shift
 12405  				if b < 0x80 {
 12406  					break
 12407  				}
 12408  			}
 12409  			if msglen < 0 {
 12410  				return ErrInvalidLength
 12411  			}
 12412  			postIndex := iNdEx + msglen
 12413  			if postIndex < 0 {
 12414  				return ErrInvalidLength
 12415  			}
 12416  			if postIndex > l {
 12417  				return io.ErrUnexpectedEOF
 12418  			}
 12419  			if m.Result == nil {
 12420  				m.Result = &QueryResult{}
 12421  			}
 12422  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12423  				return err
 12424  			}
 12425  			iNdEx = postIndex
 12426  		case 3:
 12427  			if wireType != 0 {
 12428  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 12429  			}
 12430  			m.TransactionId = 0
 12431  			for shift := uint(0); ; shift += 7 {
 12432  				if shift >= 64 {
 12433  					return ErrIntOverflow
 12434  				}
 12435  				if iNdEx >= l {
 12436  					return io.ErrUnexpectedEOF
 12437  				}
 12438  				b := dAtA[iNdEx]
 12439  				iNdEx++
 12440  				m.TransactionId |= int64(b&0x7F) << shift
 12441  				if b < 0x80 {
 12442  					break
 12443  				}
 12444  			}
 12445  		case 4:
 12446  			if wireType != 2 {
 12447  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 12448  			}
 12449  			var msglen int
 12450  			for shift := uint(0); ; shift += 7 {
 12451  				if shift >= 64 {
 12452  					return ErrIntOverflow
 12453  				}
 12454  				if iNdEx >= l {
 12455  					return io.ErrUnexpectedEOF
 12456  				}
 12457  				b := dAtA[iNdEx]
 12458  				iNdEx++
 12459  				msglen |= int(b&0x7F) << shift
 12460  				if b < 0x80 {
 12461  					break
 12462  				}
 12463  			}
 12464  			if msglen < 0 {
 12465  				return ErrInvalidLength
 12466  			}
 12467  			postIndex := iNdEx + msglen
 12468  			if postIndex < 0 {
 12469  				return ErrInvalidLength
 12470  			}
 12471  			if postIndex > l {
 12472  				return io.ErrUnexpectedEOF
 12473  			}
 12474  			if m.TabletAlias == nil {
 12475  				m.TabletAlias = &topodata.TabletAlias{}
 12476  			}
 12477  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12478  				return err
 12479  			}
 12480  			iNdEx = postIndex
 12481  		default:
 12482  			iNdEx = preIndex
 12483  			skippy, err := skip(dAtA[iNdEx:])
 12484  			if err != nil {
 12485  				return err
 12486  			}
 12487  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12488  				return ErrInvalidLength
 12489  			}
 12490  			if (iNdEx + skippy) > l {
 12491  				return io.ErrUnexpectedEOF
 12492  			}
 12493  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12494  			iNdEx += skippy
 12495  		}
 12496  	}
 12497  
 12498  	if iNdEx > l {
 12499  		return io.ErrUnexpectedEOF
 12500  	}
 12501  	return nil
 12502  }
 12503  func (m *MessageStreamRequest) UnmarshalVT(dAtA []byte) error {
 12504  	l := len(dAtA)
 12505  	iNdEx := 0
 12506  	for iNdEx < l {
 12507  		preIndex := iNdEx
 12508  		var wire uint64
 12509  		for shift := uint(0); ; shift += 7 {
 12510  			if shift >= 64 {
 12511  				return ErrIntOverflow
 12512  			}
 12513  			if iNdEx >= l {
 12514  				return io.ErrUnexpectedEOF
 12515  			}
 12516  			b := dAtA[iNdEx]
 12517  			iNdEx++
 12518  			wire |= uint64(b&0x7F) << shift
 12519  			if b < 0x80 {
 12520  				break
 12521  			}
 12522  		}
 12523  		fieldNum := int32(wire >> 3)
 12524  		wireType := int(wire & 0x7)
 12525  		if wireType == 4 {
 12526  			return fmt.Errorf("proto: MessageStreamRequest: wiretype end group for non-group")
 12527  		}
 12528  		if fieldNum <= 0 {
 12529  			return fmt.Errorf("proto: MessageStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12530  		}
 12531  		switch fieldNum {
 12532  		case 1:
 12533  			if wireType != 2 {
 12534  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 12535  			}
 12536  			var msglen int
 12537  			for shift := uint(0); ; shift += 7 {
 12538  				if shift >= 64 {
 12539  					return ErrIntOverflow
 12540  				}
 12541  				if iNdEx >= l {
 12542  					return io.ErrUnexpectedEOF
 12543  				}
 12544  				b := dAtA[iNdEx]
 12545  				iNdEx++
 12546  				msglen |= int(b&0x7F) << shift
 12547  				if b < 0x80 {
 12548  					break
 12549  				}
 12550  			}
 12551  			if msglen < 0 {
 12552  				return ErrInvalidLength
 12553  			}
 12554  			postIndex := iNdEx + msglen
 12555  			if postIndex < 0 {
 12556  				return ErrInvalidLength
 12557  			}
 12558  			if postIndex > l {
 12559  				return io.ErrUnexpectedEOF
 12560  			}
 12561  			if m.EffectiveCallerId == nil {
 12562  				m.EffectiveCallerId = &vtrpc.CallerID{}
 12563  			}
 12564  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12565  				return err
 12566  			}
 12567  			iNdEx = postIndex
 12568  		case 2:
 12569  			if wireType != 2 {
 12570  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 12571  			}
 12572  			var msglen int
 12573  			for shift := uint(0); ; shift += 7 {
 12574  				if shift >= 64 {
 12575  					return ErrIntOverflow
 12576  				}
 12577  				if iNdEx >= l {
 12578  					return io.ErrUnexpectedEOF
 12579  				}
 12580  				b := dAtA[iNdEx]
 12581  				iNdEx++
 12582  				msglen |= int(b&0x7F) << shift
 12583  				if b < 0x80 {
 12584  					break
 12585  				}
 12586  			}
 12587  			if msglen < 0 {
 12588  				return ErrInvalidLength
 12589  			}
 12590  			postIndex := iNdEx + msglen
 12591  			if postIndex < 0 {
 12592  				return ErrInvalidLength
 12593  			}
 12594  			if postIndex > l {
 12595  				return io.ErrUnexpectedEOF
 12596  			}
 12597  			if m.ImmediateCallerId == nil {
 12598  				m.ImmediateCallerId = &VTGateCallerID{}
 12599  			}
 12600  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12601  				return err
 12602  			}
 12603  			iNdEx = postIndex
 12604  		case 3:
 12605  			if wireType != 2 {
 12606  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 12607  			}
 12608  			var msglen int
 12609  			for shift := uint(0); ; shift += 7 {
 12610  				if shift >= 64 {
 12611  					return ErrIntOverflow
 12612  				}
 12613  				if iNdEx >= l {
 12614  					return io.ErrUnexpectedEOF
 12615  				}
 12616  				b := dAtA[iNdEx]
 12617  				iNdEx++
 12618  				msglen |= int(b&0x7F) << shift
 12619  				if b < 0x80 {
 12620  					break
 12621  				}
 12622  			}
 12623  			if msglen < 0 {
 12624  				return ErrInvalidLength
 12625  			}
 12626  			postIndex := iNdEx + msglen
 12627  			if postIndex < 0 {
 12628  				return ErrInvalidLength
 12629  			}
 12630  			if postIndex > l {
 12631  				return io.ErrUnexpectedEOF
 12632  			}
 12633  			if m.Target == nil {
 12634  				m.Target = &Target{}
 12635  			}
 12636  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12637  				return err
 12638  			}
 12639  			iNdEx = postIndex
 12640  		case 4:
 12641  			if wireType != 2 {
 12642  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 12643  			}
 12644  			var stringLen uint64
 12645  			for shift := uint(0); ; shift += 7 {
 12646  				if shift >= 64 {
 12647  					return ErrIntOverflow
 12648  				}
 12649  				if iNdEx >= l {
 12650  					return io.ErrUnexpectedEOF
 12651  				}
 12652  				b := dAtA[iNdEx]
 12653  				iNdEx++
 12654  				stringLen |= uint64(b&0x7F) << shift
 12655  				if b < 0x80 {
 12656  					break
 12657  				}
 12658  			}
 12659  			intStringLen := int(stringLen)
 12660  			if intStringLen < 0 {
 12661  				return ErrInvalidLength
 12662  			}
 12663  			postIndex := iNdEx + intStringLen
 12664  			if postIndex < 0 {
 12665  				return ErrInvalidLength
 12666  			}
 12667  			if postIndex > l {
 12668  				return io.ErrUnexpectedEOF
 12669  			}
 12670  			m.Name = string(dAtA[iNdEx:postIndex])
 12671  			iNdEx = postIndex
 12672  		default:
 12673  			iNdEx = preIndex
 12674  			skippy, err := skip(dAtA[iNdEx:])
 12675  			if err != nil {
 12676  				return err
 12677  			}
 12678  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12679  				return ErrInvalidLength
 12680  			}
 12681  			if (iNdEx + skippy) > l {
 12682  				return io.ErrUnexpectedEOF
 12683  			}
 12684  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12685  			iNdEx += skippy
 12686  		}
 12687  	}
 12688  
 12689  	if iNdEx > l {
 12690  		return io.ErrUnexpectedEOF
 12691  	}
 12692  	return nil
 12693  }
 12694  func (m *MessageStreamResponse) UnmarshalVT(dAtA []byte) error {
 12695  	l := len(dAtA)
 12696  	iNdEx := 0
 12697  	for iNdEx < l {
 12698  		preIndex := iNdEx
 12699  		var wire uint64
 12700  		for shift := uint(0); ; shift += 7 {
 12701  			if shift >= 64 {
 12702  				return ErrIntOverflow
 12703  			}
 12704  			if iNdEx >= l {
 12705  				return io.ErrUnexpectedEOF
 12706  			}
 12707  			b := dAtA[iNdEx]
 12708  			iNdEx++
 12709  			wire |= uint64(b&0x7F) << shift
 12710  			if b < 0x80 {
 12711  				break
 12712  			}
 12713  		}
 12714  		fieldNum := int32(wire >> 3)
 12715  		wireType := int(wire & 0x7)
 12716  		if wireType == 4 {
 12717  			return fmt.Errorf("proto: MessageStreamResponse: wiretype end group for non-group")
 12718  		}
 12719  		if fieldNum <= 0 {
 12720  			return fmt.Errorf("proto: MessageStreamResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12721  		}
 12722  		switch fieldNum {
 12723  		case 1:
 12724  			if wireType != 2 {
 12725  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 12726  			}
 12727  			var msglen int
 12728  			for shift := uint(0); ; shift += 7 {
 12729  				if shift >= 64 {
 12730  					return ErrIntOverflow
 12731  				}
 12732  				if iNdEx >= l {
 12733  					return io.ErrUnexpectedEOF
 12734  				}
 12735  				b := dAtA[iNdEx]
 12736  				iNdEx++
 12737  				msglen |= int(b&0x7F) << shift
 12738  				if b < 0x80 {
 12739  					break
 12740  				}
 12741  			}
 12742  			if msglen < 0 {
 12743  				return ErrInvalidLength
 12744  			}
 12745  			postIndex := iNdEx + msglen
 12746  			if postIndex < 0 {
 12747  				return ErrInvalidLength
 12748  			}
 12749  			if postIndex > l {
 12750  				return io.ErrUnexpectedEOF
 12751  			}
 12752  			if m.Result == nil {
 12753  				m.Result = &QueryResult{}
 12754  			}
 12755  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12756  				return err
 12757  			}
 12758  			iNdEx = postIndex
 12759  		default:
 12760  			iNdEx = preIndex
 12761  			skippy, err := skip(dAtA[iNdEx:])
 12762  			if err != nil {
 12763  				return err
 12764  			}
 12765  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12766  				return ErrInvalidLength
 12767  			}
 12768  			if (iNdEx + skippy) > l {
 12769  				return io.ErrUnexpectedEOF
 12770  			}
 12771  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12772  			iNdEx += skippy
 12773  		}
 12774  	}
 12775  
 12776  	if iNdEx > l {
 12777  		return io.ErrUnexpectedEOF
 12778  	}
 12779  	return nil
 12780  }
 12781  func (m *MessageAckRequest) UnmarshalVT(dAtA []byte) error {
 12782  	l := len(dAtA)
 12783  	iNdEx := 0
 12784  	for iNdEx < l {
 12785  		preIndex := iNdEx
 12786  		var wire uint64
 12787  		for shift := uint(0); ; shift += 7 {
 12788  			if shift >= 64 {
 12789  				return ErrIntOverflow
 12790  			}
 12791  			if iNdEx >= l {
 12792  				return io.ErrUnexpectedEOF
 12793  			}
 12794  			b := dAtA[iNdEx]
 12795  			iNdEx++
 12796  			wire |= uint64(b&0x7F) << shift
 12797  			if b < 0x80 {
 12798  				break
 12799  			}
 12800  		}
 12801  		fieldNum := int32(wire >> 3)
 12802  		wireType := int(wire & 0x7)
 12803  		if wireType == 4 {
 12804  			return fmt.Errorf("proto: MessageAckRequest: wiretype end group for non-group")
 12805  		}
 12806  		if fieldNum <= 0 {
 12807  			return fmt.Errorf("proto: MessageAckRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12808  		}
 12809  		switch fieldNum {
 12810  		case 1:
 12811  			if wireType != 2 {
 12812  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 12813  			}
 12814  			var msglen int
 12815  			for shift := uint(0); ; shift += 7 {
 12816  				if shift >= 64 {
 12817  					return ErrIntOverflow
 12818  				}
 12819  				if iNdEx >= l {
 12820  					return io.ErrUnexpectedEOF
 12821  				}
 12822  				b := dAtA[iNdEx]
 12823  				iNdEx++
 12824  				msglen |= int(b&0x7F) << shift
 12825  				if b < 0x80 {
 12826  					break
 12827  				}
 12828  			}
 12829  			if msglen < 0 {
 12830  				return ErrInvalidLength
 12831  			}
 12832  			postIndex := iNdEx + msglen
 12833  			if postIndex < 0 {
 12834  				return ErrInvalidLength
 12835  			}
 12836  			if postIndex > l {
 12837  				return io.ErrUnexpectedEOF
 12838  			}
 12839  			if m.EffectiveCallerId == nil {
 12840  				m.EffectiveCallerId = &vtrpc.CallerID{}
 12841  			}
 12842  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12843  				return err
 12844  			}
 12845  			iNdEx = postIndex
 12846  		case 2:
 12847  			if wireType != 2 {
 12848  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 12849  			}
 12850  			var msglen int
 12851  			for shift := uint(0); ; shift += 7 {
 12852  				if shift >= 64 {
 12853  					return ErrIntOverflow
 12854  				}
 12855  				if iNdEx >= l {
 12856  					return io.ErrUnexpectedEOF
 12857  				}
 12858  				b := dAtA[iNdEx]
 12859  				iNdEx++
 12860  				msglen |= int(b&0x7F) << shift
 12861  				if b < 0x80 {
 12862  					break
 12863  				}
 12864  			}
 12865  			if msglen < 0 {
 12866  				return ErrInvalidLength
 12867  			}
 12868  			postIndex := iNdEx + msglen
 12869  			if postIndex < 0 {
 12870  				return ErrInvalidLength
 12871  			}
 12872  			if postIndex > l {
 12873  				return io.ErrUnexpectedEOF
 12874  			}
 12875  			if m.ImmediateCallerId == nil {
 12876  				m.ImmediateCallerId = &VTGateCallerID{}
 12877  			}
 12878  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12879  				return err
 12880  			}
 12881  			iNdEx = postIndex
 12882  		case 3:
 12883  			if wireType != 2 {
 12884  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 12885  			}
 12886  			var msglen int
 12887  			for shift := uint(0); ; shift += 7 {
 12888  				if shift >= 64 {
 12889  					return ErrIntOverflow
 12890  				}
 12891  				if iNdEx >= l {
 12892  					return io.ErrUnexpectedEOF
 12893  				}
 12894  				b := dAtA[iNdEx]
 12895  				iNdEx++
 12896  				msglen |= int(b&0x7F) << shift
 12897  				if b < 0x80 {
 12898  					break
 12899  				}
 12900  			}
 12901  			if msglen < 0 {
 12902  				return ErrInvalidLength
 12903  			}
 12904  			postIndex := iNdEx + msglen
 12905  			if postIndex < 0 {
 12906  				return ErrInvalidLength
 12907  			}
 12908  			if postIndex > l {
 12909  				return io.ErrUnexpectedEOF
 12910  			}
 12911  			if m.Target == nil {
 12912  				m.Target = &Target{}
 12913  			}
 12914  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12915  				return err
 12916  			}
 12917  			iNdEx = postIndex
 12918  		case 4:
 12919  			if wireType != 2 {
 12920  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 12921  			}
 12922  			var stringLen uint64
 12923  			for shift := uint(0); ; shift += 7 {
 12924  				if shift >= 64 {
 12925  					return ErrIntOverflow
 12926  				}
 12927  				if iNdEx >= l {
 12928  					return io.ErrUnexpectedEOF
 12929  				}
 12930  				b := dAtA[iNdEx]
 12931  				iNdEx++
 12932  				stringLen |= uint64(b&0x7F) << shift
 12933  				if b < 0x80 {
 12934  					break
 12935  				}
 12936  			}
 12937  			intStringLen := int(stringLen)
 12938  			if intStringLen < 0 {
 12939  				return ErrInvalidLength
 12940  			}
 12941  			postIndex := iNdEx + intStringLen
 12942  			if postIndex < 0 {
 12943  				return ErrInvalidLength
 12944  			}
 12945  			if postIndex > l {
 12946  				return io.ErrUnexpectedEOF
 12947  			}
 12948  			m.Name = string(dAtA[iNdEx:postIndex])
 12949  			iNdEx = postIndex
 12950  		case 5:
 12951  			if wireType != 2 {
 12952  				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
 12953  			}
 12954  			var msglen int
 12955  			for shift := uint(0); ; shift += 7 {
 12956  				if shift >= 64 {
 12957  					return ErrIntOverflow
 12958  				}
 12959  				if iNdEx >= l {
 12960  					return io.ErrUnexpectedEOF
 12961  				}
 12962  				b := dAtA[iNdEx]
 12963  				iNdEx++
 12964  				msglen |= int(b&0x7F) << shift
 12965  				if b < 0x80 {
 12966  					break
 12967  				}
 12968  			}
 12969  			if msglen < 0 {
 12970  				return ErrInvalidLength
 12971  			}
 12972  			postIndex := iNdEx + msglen
 12973  			if postIndex < 0 {
 12974  				return ErrInvalidLength
 12975  			}
 12976  			if postIndex > l {
 12977  				return io.ErrUnexpectedEOF
 12978  			}
 12979  			m.Ids = append(m.Ids, &Value{})
 12980  			if err := m.Ids[len(m.Ids)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12981  				return err
 12982  			}
 12983  			iNdEx = postIndex
 12984  		default:
 12985  			iNdEx = preIndex
 12986  			skippy, err := skip(dAtA[iNdEx:])
 12987  			if err != nil {
 12988  				return err
 12989  			}
 12990  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12991  				return ErrInvalidLength
 12992  			}
 12993  			if (iNdEx + skippy) > l {
 12994  				return io.ErrUnexpectedEOF
 12995  			}
 12996  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12997  			iNdEx += skippy
 12998  		}
 12999  	}
 13000  
 13001  	if iNdEx > l {
 13002  		return io.ErrUnexpectedEOF
 13003  	}
 13004  	return nil
 13005  }
 13006  func (m *MessageAckResponse) UnmarshalVT(dAtA []byte) error {
 13007  	l := len(dAtA)
 13008  	iNdEx := 0
 13009  	for iNdEx < l {
 13010  		preIndex := iNdEx
 13011  		var wire uint64
 13012  		for shift := uint(0); ; shift += 7 {
 13013  			if shift >= 64 {
 13014  				return ErrIntOverflow
 13015  			}
 13016  			if iNdEx >= l {
 13017  				return io.ErrUnexpectedEOF
 13018  			}
 13019  			b := dAtA[iNdEx]
 13020  			iNdEx++
 13021  			wire |= uint64(b&0x7F) << shift
 13022  			if b < 0x80 {
 13023  				break
 13024  			}
 13025  		}
 13026  		fieldNum := int32(wire >> 3)
 13027  		wireType := int(wire & 0x7)
 13028  		if wireType == 4 {
 13029  			return fmt.Errorf("proto: MessageAckResponse: wiretype end group for non-group")
 13030  		}
 13031  		if fieldNum <= 0 {
 13032  			return fmt.Errorf("proto: MessageAckResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13033  		}
 13034  		switch fieldNum {
 13035  		case 1:
 13036  			if wireType != 2 {
 13037  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 13038  			}
 13039  			var msglen int
 13040  			for shift := uint(0); ; shift += 7 {
 13041  				if shift >= 64 {
 13042  					return ErrIntOverflow
 13043  				}
 13044  				if iNdEx >= l {
 13045  					return io.ErrUnexpectedEOF
 13046  				}
 13047  				b := dAtA[iNdEx]
 13048  				iNdEx++
 13049  				msglen |= int(b&0x7F) << shift
 13050  				if b < 0x80 {
 13051  					break
 13052  				}
 13053  			}
 13054  			if msglen < 0 {
 13055  				return ErrInvalidLength
 13056  			}
 13057  			postIndex := iNdEx + msglen
 13058  			if postIndex < 0 {
 13059  				return ErrInvalidLength
 13060  			}
 13061  			if postIndex > l {
 13062  				return io.ErrUnexpectedEOF
 13063  			}
 13064  			if m.Result == nil {
 13065  				m.Result = &QueryResult{}
 13066  			}
 13067  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13068  				return err
 13069  			}
 13070  			iNdEx = postIndex
 13071  		default:
 13072  			iNdEx = preIndex
 13073  			skippy, err := skip(dAtA[iNdEx:])
 13074  			if err != nil {
 13075  				return err
 13076  			}
 13077  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13078  				return ErrInvalidLength
 13079  			}
 13080  			if (iNdEx + skippy) > l {
 13081  				return io.ErrUnexpectedEOF
 13082  			}
 13083  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13084  			iNdEx += skippy
 13085  		}
 13086  	}
 13087  
 13088  	if iNdEx > l {
 13089  		return io.ErrUnexpectedEOF
 13090  	}
 13091  	return nil
 13092  }
 13093  func (m *ReserveExecuteRequest) UnmarshalVT(dAtA []byte) error {
 13094  	l := len(dAtA)
 13095  	iNdEx := 0
 13096  	for iNdEx < l {
 13097  		preIndex := iNdEx
 13098  		var wire uint64
 13099  		for shift := uint(0); ; shift += 7 {
 13100  			if shift >= 64 {
 13101  				return ErrIntOverflow
 13102  			}
 13103  			if iNdEx >= l {
 13104  				return io.ErrUnexpectedEOF
 13105  			}
 13106  			b := dAtA[iNdEx]
 13107  			iNdEx++
 13108  			wire |= uint64(b&0x7F) << shift
 13109  			if b < 0x80 {
 13110  				break
 13111  			}
 13112  		}
 13113  		fieldNum := int32(wire >> 3)
 13114  		wireType := int(wire & 0x7)
 13115  		if wireType == 4 {
 13116  			return fmt.Errorf("proto: ReserveExecuteRequest: wiretype end group for non-group")
 13117  		}
 13118  		if fieldNum <= 0 {
 13119  			return fmt.Errorf("proto: ReserveExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13120  		}
 13121  		switch fieldNum {
 13122  		case 1:
 13123  			if wireType != 2 {
 13124  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 13125  			}
 13126  			var msglen int
 13127  			for shift := uint(0); ; shift += 7 {
 13128  				if shift >= 64 {
 13129  					return ErrIntOverflow
 13130  				}
 13131  				if iNdEx >= l {
 13132  					return io.ErrUnexpectedEOF
 13133  				}
 13134  				b := dAtA[iNdEx]
 13135  				iNdEx++
 13136  				msglen |= int(b&0x7F) << shift
 13137  				if b < 0x80 {
 13138  					break
 13139  				}
 13140  			}
 13141  			if msglen < 0 {
 13142  				return ErrInvalidLength
 13143  			}
 13144  			postIndex := iNdEx + msglen
 13145  			if postIndex < 0 {
 13146  				return ErrInvalidLength
 13147  			}
 13148  			if postIndex > l {
 13149  				return io.ErrUnexpectedEOF
 13150  			}
 13151  			if m.EffectiveCallerId == nil {
 13152  				m.EffectiveCallerId = &vtrpc.CallerID{}
 13153  			}
 13154  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13155  				return err
 13156  			}
 13157  			iNdEx = postIndex
 13158  		case 2:
 13159  			if wireType != 2 {
 13160  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 13161  			}
 13162  			var msglen int
 13163  			for shift := uint(0); ; shift += 7 {
 13164  				if shift >= 64 {
 13165  					return ErrIntOverflow
 13166  				}
 13167  				if iNdEx >= l {
 13168  					return io.ErrUnexpectedEOF
 13169  				}
 13170  				b := dAtA[iNdEx]
 13171  				iNdEx++
 13172  				msglen |= int(b&0x7F) << shift
 13173  				if b < 0x80 {
 13174  					break
 13175  				}
 13176  			}
 13177  			if msglen < 0 {
 13178  				return ErrInvalidLength
 13179  			}
 13180  			postIndex := iNdEx + msglen
 13181  			if postIndex < 0 {
 13182  				return ErrInvalidLength
 13183  			}
 13184  			if postIndex > l {
 13185  				return io.ErrUnexpectedEOF
 13186  			}
 13187  			if m.ImmediateCallerId == nil {
 13188  				m.ImmediateCallerId = &VTGateCallerID{}
 13189  			}
 13190  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13191  				return err
 13192  			}
 13193  			iNdEx = postIndex
 13194  		case 3:
 13195  			if wireType != 2 {
 13196  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 13197  			}
 13198  			var msglen int
 13199  			for shift := uint(0); ; shift += 7 {
 13200  				if shift >= 64 {
 13201  					return ErrIntOverflow
 13202  				}
 13203  				if iNdEx >= l {
 13204  					return io.ErrUnexpectedEOF
 13205  				}
 13206  				b := dAtA[iNdEx]
 13207  				iNdEx++
 13208  				msglen |= int(b&0x7F) << shift
 13209  				if b < 0x80 {
 13210  					break
 13211  				}
 13212  			}
 13213  			if msglen < 0 {
 13214  				return ErrInvalidLength
 13215  			}
 13216  			postIndex := iNdEx + msglen
 13217  			if postIndex < 0 {
 13218  				return ErrInvalidLength
 13219  			}
 13220  			if postIndex > l {
 13221  				return io.ErrUnexpectedEOF
 13222  			}
 13223  			if m.Target == nil {
 13224  				m.Target = &Target{}
 13225  			}
 13226  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13227  				return err
 13228  			}
 13229  			iNdEx = postIndex
 13230  		case 4:
 13231  			if wireType != 2 {
 13232  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 13233  			}
 13234  			var msglen int
 13235  			for shift := uint(0); ; shift += 7 {
 13236  				if shift >= 64 {
 13237  					return ErrIntOverflow
 13238  				}
 13239  				if iNdEx >= l {
 13240  					return io.ErrUnexpectedEOF
 13241  				}
 13242  				b := dAtA[iNdEx]
 13243  				iNdEx++
 13244  				msglen |= int(b&0x7F) << shift
 13245  				if b < 0x80 {
 13246  					break
 13247  				}
 13248  			}
 13249  			if msglen < 0 {
 13250  				return ErrInvalidLength
 13251  			}
 13252  			postIndex := iNdEx + msglen
 13253  			if postIndex < 0 {
 13254  				return ErrInvalidLength
 13255  			}
 13256  			if postIndex > l {
 13257  				return io.ErrUnexpectedEOF
 13258  			}
 13259  			if m.Query == nil {
 13260  				m.Query = &BoundQuery{}
 13261  			}
 13262  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13263  				return err
 13264  			}
 13265  			iNdEx = postIndex
 13266  		case 5:
 13267  			if wireType != 0 {
 13268  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 13269  			}
 13270  			m.TransactionId = 0
 13271  			for shift := uint(0); ; shift += 7 {
 13272  				if shift >= 64 {
 13273  					return ErrIntOverflow
 13274  				}
 13275  				if iNdEx >= l {
 13276  					return io.ErrUnexpectedEOF
 13277  				}
 13278  				b := dAtA[iNdEx]
 13279  				iNdEx++
 13280  				m.TransactionId |= int64(b&0x7F) << shift
 13281  				if b < 0x80 {
 13282  					break
 13283  				}
 13284  			}
 13285  		case 6:
 13286  			if wireType != 2 {
 13287  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 13288  			}
 13289  			var msglen int
 13290  			for shift := uint(0); ; shift += 7 {
 13291  				if shift >= 64 {
 13292  					return ErrIntOverflow
 13293  				}
 13294  				if iNdEx >= l {
 13295  					return io.ErrUnexpectedEOF
 13296  				}
 13297  				b := dAtA[iNdEx]
 13298  				iNdEx++
 13299  				msglen |= int(b&0x7F) << shift
 13300  				if b < 0x80 {
 13301  					break
 13302  				}
 13303  			}
 13304  			if msglen < 0 {
 13305  				return ErrInvalidLength
 13306  			}
 13307  			postIndex := iNdEx + msglen
 13308  			if postIndex < 0 {
 13309  				return ErrInvalidLength
 13310  			}
 13311  			if postIndex > l {
 13312  				return io.ErrUnexpectedEOF
 13313  			}
 13314  			if m.Options == nil {
 13315  				m.Options = &ExecuteOptions{}
 13316  			}
 13317  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13318  				return err
 13319  			}
 13320  			iNdEx = postIndex
 13321  		case 7:
 13322  			if wireType != 2 {
 13323  				return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType)
 13324  			}
 13325  			var stringLen uint64
 13326  			for shift := uint(0); ; shift += 7 {
 13327  				if shift >= 64 {
 13328  					return ErrIntOverflow
 13329  				}
 13330  				if iNdEx >= l {
 13331  					return io.ErrUnexpectedEOF
 13332  				}
 13333  				b := dAtA[iNdEx]
 13334  				iNdEx++
 13335  				stringLen |= uint64(b&0x7F) << shift
 13336  				if b < 0x80 {
 13337  					break
 13338  				}
 13339  			}
 13340  			intStringLen := int(stringLen)
 13341  			if intStringLen < 0 {
 13342  				return ErrInvalidLength
 13343  			}
 13344  			postIndex := iNdEx + intStringLen
 13345  			if postIndex < 0 {
 13346  				return ErrInvalidLength
 13347  			}
 13348  			if postIndex > l {
 13349  				return io.ErrUnexpectedEOF
 13350  			}
 13351  			m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex]))
 13352  			iNdEx = postIndex
 13353  		default:
 13354  			iNdEx = preIndex
 13355  			skippy, err := skip(dAtA[iNdEx:])
 13356  			if err != nil {
 13357  				return err
 13358  			}
 13359  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13360  				return ErrInvalidLength
 13361  			}
 13362  			if (iNdEx + skippy) > l {
 13363  				return io.ErrUnexpectedEOF
 13364  			}
 13365  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13366  			iNdEx += skippy
 13367  		}
 13368  	}
 13369  
 13370  	if iNdEx > l {
 13371  		return io.ErrUnexpectedEOF
 13372  	}
 13373  	return nil
 13374  }
 13375  func (m *ReserveExecuteResponse) UnmarshalVT(dAtA []byte) error {
 13376  	l := len(dAtA)
 13377  	iNdEx := 0
 13378  	for iNdEx < l {
 13379  		preIndex := iNdEx
 13380  		var wire uint64
 13381  		for shift := uint(0); ; shift += 7 {
 13382  			if shift >= 64 {
 13383  				return ErrIntOverflow
 13384  			}
 13385  			if iNdEx >= l {
 13386  				return io.ErrUnexpectedEOF
 13387  			}
 13388  			b := dAtA[iNdEx]
 13389  			iNdEx++
 13390  			wire |= uint64(b&0x7F) << shift
 13391  			if b < 0x80 {
 13392  				break
 13393  			}
 13394  		}
 13395  		fieldNum := int32(wire >> 3)
 13396  		wireType := int(wire & 0x7)
 13397  		if wireType == 4 {
 13398  			return fmt.Errorf("proto: ReserveExecuteResponse: wiretype end group for non-group")
 13399  		}
 13400  		if fieldNum <= 0 {
 13401  			return fmt.Errorf("proto: ReserveExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13402  		}
 13403  		switch fieldNum {
 13404  		case 1:
 13405  			if wireType != 2 {
 13406  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 13407  			}
 13408  			var msglen int
 13409  			for shift := uint(0); ; shift += 7 {
 13410  				if shift >= 64 {
 13411  					return ErrIntOverflow
 13412  				}
 13413  				if iNdEx >= l {
 13414  					return io.ErrUnexpectedEOF
 13415  				}
 13416  				b := dAtA[iNdEx]
 13417  				iNdEx++
 13418  				msglen |= int(b&0x7F) << shift
 13419  				if b < 0x80 {
 13420  					break
 13421  				}
 13422  			}
 13423  			if msglen < 0 {
 13424  				return ErrInvalidLength
 13425  			}
 13426  			postIndex := iNdEx + msglen
 13427  			if postIndex < 0 {
 13428  				return ErrInvalidLength
 13429  			}
 13430  			if postIndex > l {
 13431  				return io.ErrUnexpectedEOF
 13432  			}
 13433  			if m.Error == nil {
 13434  				m.Error = &vtrpc.RPCError{}
 13435  			}
 13436  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13437  				return err
 13438  			}
 13439  			iNdEx = postIndex
 13440  		case 2:
 13441  			if wireType != 2 {
 13442  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 13443  			}
 13444  			var msglen int
 13445  			for shift := uint(0); ; shift += 7 {
 13446  				if shift >= 64 {
 13447  					return ErrIntOverflow
 13448  				}
 13449  				if iNdEx >= l {
 13450  					return io.ErrUnexpectedEOF
 13451  				}
 13452  				b := dAtA[iNdEx]
 13453  				iNdEx++
 13454  				msglen |= int(b&0x7F) << shift
 13455  				if b < 0x80 {
 13456  					break
 13457  				}
 13458  			}
 13459  			if msglen < 0 {
 13460  				return ErrInvalidLength
 13461  			}
 13462  			postIndex := iNdEx + msglen
 13463  			if postIndex < 0 {
 13464  				return ErrInvalidLength
 13465  			}
 13466  			if postIndex > l {
 13467  				return io.ErrUnexpectedEOF
 13468  			}
 13469  			if m.Result == nil {
 13470  				m.Result = &QueryResult{}
 13471  			}
 13472  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13473  				return err
 13474  			}
 13475  			iNdEx = postIndex
 13476  		case 3:
 13477  			if wireType != 0 {
 13478  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 13479  			}
 13480  			m.ReservedId = 0
 13481  			for shift := uint(0); ; shift += 7 {
 13482  				if shift >= 64 {
 13483  					return ErrIntOverflow
 13484  				}
 13485  				if iNdEx >= l {
 13486  					return io.ErrUnexpectedEOF
 13487  				}
 13488  				b := dAtA[iNdEx]
 13489  				iNdEx++
 13490  				m.ReservedId |= int64(b&0x7F) << shift
 13491  				if b < 0x80 {
 13492  					break
 13493  				}
 13494  			}
 13495  		case 4:
 13496  			if wireType != 2 {
 13497  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 13498  			}
 13499  			var msglen int
 13500  			for shift := uint(0); ; shift += 7 {
 13501  				if shift >= 64 {
 13502  					return ErrIntOverflow
 13503  				}
 13504  				if iNdEx >= l {
 13505  					return io.ErrUnexpectedEOF
 13506  				}
 13507  				b := dAtA[iNdEx]
 13508  				iNdEx++
 13509  				msglen |= int(b&0x7F) << shift
 13510  				if b < 0x80 {
 13511  					break
 13512  				}
 13513  			}
 13514  			if msglen < 0 {
 13515  				return ErrInvalidLength
 13516  			}
 13517  			postIndex := iNdEx + msglen
 13518  			if postIndex < 0 {
 13519  				return ErrInvalidLength
 13520  			}
 13521  			if postIndex > l {
 13522  				return io.ErrUnexpectedEOF
 13523  			}
 13524  			if m.TabletAlias == nil {
 13525  				m.TabletAlias = &topodata.TabletAlias{}
 13526  			}
 13527  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13528  				return err
 13529  			}
 13530  			iNdEx = postIndex
 13531  		default:
 13532  			iNdEx = preIndex
 13533  			skippy, err := skip(dAtA[iNdEx:])
 13534  			if err != nil {
 13535  				return err
 13536  			}
 13537  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13538  				return ErrInvalidLength
 13539  			}
 13540  			if (iNdEx + skippy) > l {
 13541  				return io.ErrUnexpectedEOF
 13542  			}
 13543  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13544  			iNdEx += skippy
 13545  		}
 13546  	}
 13547  
 13548  	if iNdEx > l {
 13549  		return io.ErrUnexpectedEOF
 13550  	}
 13551  	return nil
 13552  }
 13553  func (m *ReserveStreamExecuteRequest) UnmarshalVT(dAtA []byte) error {
 13554  	l := len(dAtA)
 13555  	iNdEx := 0
 13556  	for iNdEx < l {
 13557  		preIndex := iNdEx
 13558  		var wire uint64
 13559  		for shift := uint(0); ; shift += 7 {
 13560  			if shift >= 64 {
 13561  				return ErrIntOverflow
 13562  			}
 13563  			if iNdEx >= l {
 13564  				return io.ErrUnexpectedEOF
 13565  			}
 13566  			b := dAtA[iNdEx]
 13567  			iNdEx++
 13568  			wire |= uint64(b&0x7F) << shift
 13569  			if b < 0x80 {
 13570  				break
 13571  			}
 13572  		}
 13573  		fieldNum := int32(wire >> 3)
 13574  		wireType := int(wire & 0x7)
 13575  		if wireType == 4 {
 13576  			return fmt.Errorf("proto: ReserveStreamExecuteRequest: wiretype end group for non-group")
 13577  		}
 13578  		if fieldNum <= 0 {
 13579  			return fmt.Errorf("proto: ReserveStreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13580  		}
 13581  		switch fieldNum {
 13582  		case 1:
 13583  			if wireType != 2 {
 13584  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 13585  			}
 13586  			var msglen int
 13587  			for shift := uint(0); ; shift += 7 {
 13588  				if shift >= 64 {
 13589  					return ErrIntOverflow
 13590  				}
 13591  				if iNdEx >= l {
 13592  					return io.ErrUnexpectedEOF
 13593  				}
 13594  				b := dAtA[iNdEx]
 13595  				iNdEx++
 13596  				msglen |= int(b&0x7F) << shift
 13597  				if b < 0x80 {
 13598  					break
 13599  				}
 13600  			}
 13601  			if msglen < 0 {
 13602  				return ErrInvalidLength
 13603  			}
 13604  			postIndex := iNdEx + msglen
 13605  			if postIndex < 0 {
 13606  				return ErrInvalidLength
 13607  			}
 13608  			if postIndex > l {
 13609  				return io.ErrUnexpectedEOF
 13610  			}
 13611  			if m.EffectiveCallerId == nil {
 13612  				m.EffectiveCallerId = &vtrpc.CallerID{}
 13613  			}
 13614  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13615  				return err
 13616  			}
 13617  			iNdEx = postIndex
 13618  		case 2:
 13619  			if wireType != 2 {
 13620  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 13621  			}
 13622  			var msglen int
 13623  			for shift := uint(0); ; shift += 7 {
 13624  				if shift >= 64 {
 13625  					return ErrIntOverflow
 13626  				}
 13627  				if iNdEx >= l {
 13628  					return io.ErrUnexpectedEOF
 13629  				}
 13630  				b := dAtA[iNdEx]
 13631  				iNdEx++
 13632  				msglen |= int(b&0x7F) << shift
 13633  				if b < 0x80 {
 13634  					break
 13635  				}
 13636  			}
 13637  			if msglen < 0 {
 13638  				return ErrInvalidLength
 13639  			}
 13640  			postIndex := iNdEx + msglen
 13641  			if postIndex < 0 {
 13642  				return ErrInvalidLength
 13643  			}
 13644  			if postIndex > l {
 13645  				return io.ErrUnexpectedEOF
 13646  			}
 13647  			if m.ImmediateCallerId == nil {
 13648  				m.ImmediateCallerId = &VTGateCallerID{}
 13649  			}
 13650  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13651  				return err
 13652  			}
 13653  			iNdEx = postIndex
 13654  		case 3:
 13655  			if wireType != 2 {
 13656  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 13657  			}
 13658  			var msglen int
 13659  			for shift := uint(0); ; shift += 7 {
 13660  				if shift >= 64 {
 13661  					return ErrIntOverflow
 13662  				}
 13663  				if iNdEx >= l {
 13664  					return io.ErrUnexpectedEOF
 13665  				}
 13666  				b := dAtA[iNdEx]
 13667  				iNdEx++
 13668  				msglen |= int(b&0x7F) << shift
 13669  				if b < 0x80 {
 13670  					break
 13671  				}
 13672  			}
 13673  			if msglen < 0 {
 13674  				return ErrInvalidLength
 13675  			}
 13676  			postIndex := iNdEx + msglen
 13677  			if postIndex < 0 {
 13678  				return ErrInvalidLength
 13679  			}
 13680  			if postIndex > l {
 13681  				return io.ErrUnexpectedEOF
 13682  			}
 13683  			if m.Target == nil {
 13684  				m.Target = &Target{}
 13685  			}
 13686  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13687  				return err
 13688  			}
 13689  			iNdEx = postIndex
 13690  		case 4:
 13691  			if wireType != 2 {
 13692  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 13693  			}
 13694  			var msglen int
 13695  			for shift := uint(0); ; shift += 7 {
 13696  				if shift >= 64 {
 13697  					return ErrIntOverflow
 13698  				}
 13699  				if iNdEx >= l {
 13700  					return io.ErrUnexpectedEOF
 13701  				}
 13702  				b := dAtA[iNdEx]
 13703  				iNdEx++
 13704  				msglen |= int(b&0x7F) << shift
 13705  				if b < 0x80 {
 13706  					break
 13707  				}
 13708  			}
 13709  			if msglen < 0 {
 13710  				return ErrInvalidLength
 13711  			}
 13712  			postIndex := iNdEx + msglen
 13713  			if postIndex < 0 {
 13714  				return ErrInvalidLength
 13715  			}
 13716  			if postIndex > l {
 13717  				return io.ErrUnexpectedEOF
 13718  			}
 13719  			if m.Query == nil {
 13720  				m.Query = &BoundQuery{}
 13721  			}
 13722  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13723  				return err
 13724  			}
 13725  			iNdEx = postIndex
 13726  		case 5:
 13727  			if wireType != 2 {
 13728  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 13729  			}
 13730  			var msglen int
 13731  			for shift := uint(0); ; shift += 7 {
 13732  				if shift >= 64 {
 13733  					return ErrIntOverflow
 13734  				}
 13735  				if iNdEx >= l {
 13736  					return io.ErrUnexpectedEOF
 13737  				}
 13738  				b := dAtA[iNdEx]
 13739  				iNdEx++
 13740  				msglen |= int(b&0x7F) << shift
 13741  				if b < 0x80 {
 13742  					break
 13743  				}
 13744  			}
 13745  			if msglen < 0 {
 13746  				return ErrInvalidLength
 13747  			}
 13748  			postIndex := iNdEx + msglen
 13749  			if postIndex < 0 {
 13750  				return ErrInvalidLength
 13751  			}
 13752  			if postIndex > l {
 13753  				return io.ErrUnexpectedEOF
 13754  			}
 13755  			if m.Options == nil {
 13756  				m.Options = &ExecuteOptions{}
 13757  			}
 13758  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13759  				return err
 13760  			}
 13761  			iNdEx = postIndex
 13762  		case 6:
 13763  			if wireType != 0 {
 13764  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 13765  			}
 13766  			m.TransactionId = 0
 13767  			for shift := uint(0); ; shift += 7 {
 13768  				if shift >= 64 {
 13769  					return ErrIntOverflow
 13770  				}
 13771  				if iNdEx >= l {
 13772  					return io.ErrUnexpectedEOF
 13773  				}
 13774  				b := dAtA[iNdEx]
 13775  				iNdEx++
 13776  				m.TransactionId |= int64(b&0x7F) << shift
 13777  				if b < 0x80 {
 13778  					break
 13779  				}
 13780  			}
 13781  		case 7:
 13782  			if wireType != 2 {
 13783  				return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType)
 13784  			}
 13785  			var stringLen uint64
 13786  			for shift := uint(0); ; shift += 7 {
 13787  				if shift >= 64 {
 13788  					return ErrIntOverflow
 13789  				}
 13790  				if iNdEx >= l {
 13791  					return io.ErrUnexpectedEOF
 13792  				}
 13793  				b := dAtA[iNdEx]
 13794  				iNdEx++
 13795  				stringLen |= uint64(b&0x7F) << shift
 13796  				if b < 0x80 {
 13797  					break
 13798  				}
 13799  			}
 13800  			intStringLen := int(stringLen)
 13801  			if intStringLen < 0 {
 13802  				return ErrInvalidLength
 13803  			}
 13804  			postIndex := iNdEx + intStringLen
 13805  			if postIndex < 0 {
 13806  				return ErrInvalidLength
 13807  			}
 13808  			if postIndex > l {
 13809  				return io.ErrUnexpectedEOF
 13810  			}
 13811  			m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex]))
 13812  			iNdEx = postIndex
 13813  		default:
 13814  			iNdEx = preIndex
 13815  			skippy, err := skip(dAtA[iNdEx:])
 13816  			if err != nil {
 13817  				return err
 13818  			}
 13819  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13820  				return ErrInvalidLength
 13821  			}
 13822  			if (iNdEx + skippy) > l {
 13823  				return io.ErrUnexpectedEOF
 13824  			}
 13825  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13826  			iNdEx += skippy
 13827  		}
 13828  	}
 13829  
 13830  	if iNdEx > l {
 13831  		return io.ErrUnexpectedEOF
 13832  	}
 13833  	return nil
 13834  }
 13835  func (m *ReserveStreamExecuteResponse) UnmarshalVT(dAtA []byte) error {
 13836  	l := len(dAtA)
 13837  	iNdEx := 0
 13838  	for iNdEx < l {
 13839  		preIndex := iNdEx
 13840  		var wire uint64
 13841  		for shift := uint(0); ; shift += 7 {
 13842  			if shift >= 64 {
 13843  				return ErrIntOverflow
 13844  			}
 13845  			if iNdEx >= l {
 13846  				return io.ErrUnexpectedEOF
 13847  			}
 13848  			b := dAtA[iNdEx]
 13849  			iNdEx++
 13850  			wire |= uint64(b&0x7F) << shift
 13851  			if b < 0x80 {
 13852  				break
 13853  			}
 13854  		}
 13855  		fieldNum := int32(wire >> 3)
 13856  		wireType := int(wire & 0x7)
 13857  		if wireType == 4 {
 13858  			return fmt.Errorf("proto: ReserveStreamExecuteResponse: wiretype end group for non-group")
 13859  		}
 13860  		if fieldNum <= 0 {
 13861  			return fmt.Errorf("proto: ReserveStreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13862  		}
 13863  		switch fieldNum {
 13864  		case 1:
 13865  			if wireType != 2 {
 13866  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 13867  			}
 13868  			var msglen int
 13869  			for shift := uint(0); ; shift += 7 {
 13870  				if shift >= 64 {
 13871  					return ErrIntOverflow
 13872  				}
 13873  				if iNdEx >= l {
 13874  					return io.ErrUnexpectedEOF
 13875  				}
 13876  				b := dAtA[iNdEx]
 13877  				iNdEx++
 13878  				msglen |= int(b&0x7F) << shift
 13879  				if b < 0x80 {
 13880  					break
 13881  				}
 13882  			}
 13883  			if msglen < 0 {
 13884  				return ErrInvalidLength
 13885  			}
 13886  			postIndex := iNdEx + msglen
 13887  			if postIndex < 0 {
 13888  				return ErrInvalidLength
 13889  			}
 13890  			if postIndex > l {
 13891  				return io.ErrUnexpectedEOF
 13892  			}
 13893  			if m.Error == nil {
 13894  				m.Error = &vtrpc.RPCError{}
 13895  			}
 13896  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13897  				return err
 13898  			}
 13899  			iNdEx = postIndex
 13900  		case 2:
 13901  			if wireType != 2 {
 13902  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 13903  			}
 13904  			var msglen int
 13905  			for shift := uint(0); ; shift += 7 {
 13906  				if shift >= 64 {
 13907  					return ErrIntOverflow
 13908  				}
 13909  				if iNdEx >= l {
 13910  					return io.ErrUnexpectedEOF
 13911  				}
 13912  				b := dAtA[iNdEx]
 13913  				iNdEx++
 13914  				msglen |= int(b&0x7F) << shift
 13915  				if b < 0x80 {
 13916  					break
 13917  				}
 13918  			}
 13919  			if msglen < 0 {
 13920  				return ErrInvalidLength
 13921  			}
 13922  			postIndex := iNdEx + msglen
 13923  			if postIndex < 0 {
 13924  				return ErrInvalidLength
 13925  			}
 13926  			if postIndex > l {
 13927  				return io.ErrUnexpectedEOF
 13928  			}
 13929  			if m.Result == nil {
 13930  				m.Result = &QueryResult{}
 13931  			}
 13932  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13933  				return err
 13934  			}
 13935  			iNdEx = postIndex
 13936  		case 3:
 13937  			if wireType != 0 {
 13938  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 13939  			}
 13940  			m.ReservedId = 0
 13941  			for shift := uint(0); ; shift += 7 {
 13942  				if shift >= 64 {
 13943  					return ErrIntOverflow
 13944  				}
 13945  				if iNdEx >= l {
 13946  					return io.ErrUnexpectedEOF
 13947  				}
 13948  				b := dAtA[iNdEx]
 13949  				iNdEx++
 13950  				m.ReservedId |= int64(b&0x7F) << shift
 13951  				if b < 0x80 {
 13952  					break
 13953  				}
 13954  			}
 13955  		case 4:
 13956  			if wireType != 2 {
 13957  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 13958  			}
 13959  			var msglen int
 13960  			for shift := uint(0); ; shift += 7 {
 13961  				if shift >= 64 {
 13962  					return ErrIntOverflow
 13963  				}
 13964  				if iNdEx >= l {
 13965  					return io.ErrUnexpectedEOF
 13966  				}
 13967  				b := dAtA[iNdEx]
 13968  				iNdEx++
 13969  				msglen |= int(b&0x7F) << shift
 13970  				if b < 0x80 {
 13971  					break
 13972  				}
 13973  			}
 13974  			if msglen < 0 {
 13975  				return ErrInvalidLength
 13976  			}
 13977  			postIndex := iNdEx + msglen
 13978  			if postIndex < 0 {
 13979  				return ErrInvalidLength
 13980  			}
 13981  			if postIndex > l {
 13982  				return io.ErrUnexpectedEOF
 13983  			}
 13984  			if m.TabletAlias == nil {
 13985  				m.TabletAlias = &topodata.TabletAlias{}
 13986  			}
 13987  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13988  				return err
 13989  			}
 13990  			iNdEx = postIndex
 13991  		default:
 13992  			iNdEx = preIndex
 13993  			skippy, err := skip(dAtA[iNdEx:])
 13994  			if err != nil {
 13995  				return err
 13996  			}
 13997  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13998  				return ErrInvalidLength
 13999  			}
 14000  			if (iNdEx + skippy) > l {
 14001  				return io.ErrUnexpectedEOF
 14002  			}
 14003  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14004  			iNdEx += skippy
 14005  		}
 14006  	}
 14007  
 14008  	if iNdEx > l {
 14009  		return io.ErrUnexpectedEOF
 14010  	}
 14011  	return nil
 14012  }
 14013  func (m *ReserveBeginExecuteRequest) UnmarshalVT(dAtA []byte) error {
 14014  	l := len(dAtA)
 14015  	iNdEx := 0
 14016  	for iNdEx < l {
 14017  		preIndex := iNdEx
 14018  		var wire uint64
 14019  		for shift := uint(0); ; shift += 7 {
 14020  			if shift >= 64 {
 14021  				return ErrIntOverflow
 14022  			}
 14023  			if iNdEx >= l {
 14024  				return io.ErrUnexpectedEOF
 14025  			}
 14026  			b := dAtA[iNdEx]
 14027  			iNdEx++
 14028  			wire |= uint64(b&0x7F) << shift
 14029  			if b < 0x80 {
 14030  				break
 14031  			}
 14032  		}
 14033  		fieldNum := int32(wire >> 3)
 14034  		wireType := int(wire & 0x7)
 14035  		if wireType == 4 {
 14036  			return fmt.Errorf("proto: ReserveBeginExecuteRequest: wiretype end group for non-group")
 14037  		}
 14038  		if fieldNum <= 0 {
 14039  			return fmt.Errorf("proto: ReserveBeginExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14040  		}
 14041  		switch fieldNum {
 14042  		case 1:
 14043  			if wireType != 2 {
 14044  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 14045  			}
 14046  			var msglen int
 14047  			for shift := uint(0); ; shift += 7 {
 14048  				if shift >= 64 {
 14049  					return ErrIntOverflow
 14050  				}
 14051  				if iNdEx >= l {
 14052  					return io.ErrUnexpectedEOF
 14053  				}
 14054  				b := dAtA[iNdEx]
 14055  				iNdEx++
 14056  				msglen |= int(b&0x7F) << shift
 14057  				if b < 0x80 {
 14058  					break
 14059  				}
 14060  			}
 14061  			if msglen < 0 {
 14062  				return ErrInvalidLength
 14063  			}
 14064  			postIndex := iNdEx + msglen
 14065  			if postIndex < 0 {
 14066  				return ErrInvalidLength
 14067  			}
 14068  			if postIndex > l {
 14069  				return io.ErrUnexpectedEOF
 14070  			}
 14071  			if m.EffectiveCallerId == nil {
 14072  				m.EffectiveCallerId = &vtrpc.CallerID{}
 14073  			}
 14074  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14075  				return err
 14076  			}
 14077  			iNdEx = postIndex
 14078  		case 2:
 14079  			if wireType != 2 {
 14080  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 14081  			}
 14082  			var msglen int
 14083  			for shift := uint(0); ; shift += 7 {
 14084  				if shift >= 64 {
 14085  					return ErrIntOverflow
 14086  				}
 14087  				if iNdEx >= l {
 14088  					return io.ErrUnexpectedEOF
 14089  				}
 14090  				b := dAtA[iNdEx]
 14091  				iNdEx++
 14092  				msglen |= int(b&0x7F) << shift
 14093  				if b < 0x80 {
 14094  					break
 14095  				}
 14096  			}
 14097  			if msglen < 0 {
 14098  				return ErrInvalidLength
 14099  			}
 14100  			postIndex := iNdEx + msglen
 14101  			if postIndex < 0 {
 14102  				return ErrInvalidLength
 14103  			}
 14104  			if postIndex > l {
 14105  				return io.ErrUnexpectedEOF
 14106  			}
 14107  			if m.ImmediateCallerId == nil {
 14108  				m.ImmediateCallerId = &VTGateCallerID{}
 14109  			}
 14110  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14111  				return err
 14112  			}
 14113  			iNdEx = postIndex
 14114  		case 3:
 14115  			if wireType != 2 {
 14116  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 14117  			}
 14118  			var msglen int
 14119  			for shift := uint(0); ; shift += 7 {
 14120  				if shift >= 64 {
 14121  					return ErrIntOverflow
 14122  				}
 14123  				if iNdEx >= l {
 14124  					return io.ErrUnexpectedEOF
 14125  				}
 14126  				b := dAtA[iNdEx]
 14127  				iNdEx++
 14128  				msglen |= int(b&0x7F) << shift
 14129  				if b < 0x80 {
 14130  					break
 14131  				}
 14132  			}
 14133  			if msglen < 0 {
 14134  				return ErrInvalidLength
 14135  			}
 14136  			postIndex := iNdEx + msglen
 14137  			if postIndex < 0 {
 14138  				return ErrInvalidLength
 14139  			}
 14140  			if postIndex > l {
 14141  				return io.ErrUnexpectedEOF
 14142  			}
 14143  			if m.Target == nil {
 14144  				m.Target = &Target{}
 14145  			}
 14146  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14147  				return err
 14148  			}
 14149  			iNdEx = postIndex
 14150  		case 4:
 14151  			if wireType != 2 {
 14152  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 14153  			}
 14154  			var msglen int
 14155  			for shift := uint(0); ; shift += 7 {
 14156  				if shift >= 64 {
 14157  					return ErrIntOverflow
 14158  				}
 14159  				if iNdEx >= l {
 14160  					return io.ErrUnexpectedEOF
 14161  				}
 14162  				b := dAtA[iNdEx]
 14163  				iNdEx++
 14164  				msglen |= int(b&0x7F) << shift
 14165  				if b < 0x80 {
 14166  					break
 14167  				}
 14168  			}
 14169  			if msglen < 0 {
 14170  				return ErrInvalidLength
 14171  			}
 14172  			postIndex := iNdEx + msglen
 14173  			if postIndex < 0 {
 14174  				return ErrInvalidLength
 14175  			}
 14176  			if postIndex > l {
 14177  				return io.ErrUnexpectedEOF
 14178  			}
 14179  			if m.Query == nil {
 14180  				m.Query = &BoundQuery{}
 14181  			}
 14182  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14183  				return err
 14184  			}
 14185  			iNdEx = postIndex
 14186  		case 5:
 14187  			if wireType != 2 {
 14188  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 14189  			}
 14190  			var msglen int
 14191  			for shift := uint(0); ; shift += 7 {
 14192  				if shift >= 64 {
 14193  					return ErrIntOverflow
 14194  				}
 14195  				if iNdEx >= l {
 14196  					return io.ErrUnexpectedEOF
 14197  				}
 14198  				b := dAtA[iNdEx]
 14199  				iNdEx++
 14200  				msglen |= int(b&0x7F) << shift
 14201  				if b < 0x80 {
 14202  					break
 14203  				}
 14204  			}
 14205  			if msglen < 0 {
 14206  				return ErrInvalidLength
 14207  			}
 14208  			postIndex := iNdEx + msglen
 14209  			if postIndex < 0 {
 14210  				return ErrInvalidLength
 14211  			}
 14212  			if postIndex > l {
 14213  				return io.ErrUnexpectedEOF
 14214  			}
 14215  			if m.Options == nil {
 14216  				m.Options = &ExecuteOptions{}
 14217  			}
 14218  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14219  				return err
 14220  			}
 14221  			iNdEx = postIndex
 14222  		case 6:
 14223  			if wireType != 2 {
 14224  				return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType)
 14225  			}
 14226  			var stringLen uint64
 14227  			for shift := uint(0); ; shift += 7 {
 14228  				if shift >= 64 {
 14229  					return ErrIntOverflow
 14230  				}
 14231  				if iNdEx >= l {
 14232  					return io.ErrUnexpectedEOF
 14233  				}
 14234  				b := dAtA[iNdEx]
 14235  				iNdEx++
 14236  				stringLen |= uint64(b&0x7F) << shift
 14237  				if b < 0x80 {
 14238  					break
 14239  				}
 14240  			}
 14241  			intStringLen := int(stringLen)
 14242  			if intStringLen < 0 {
 14243  				return ErrInvalidLength
 14244  			}
 14245  			postIndex := iNdEx + intStringLen
 14246  			if postIndex < 0 {
 14247  				return ErrInvalidLength
 14248  			}
 14249  			if postIndex > l {
 14250  				return io.ErrUnexpectedEOF
 14251  			}
 14252  			m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex]))
 14253  			iNdEx = postIndex
 14254  		case 7:
 14255  			if wireType != 2 {
 14256  				return fmt.Errorf("proto: wrong wireType = %d for field PostBeginQueries", wireType)
 14257  			}
 14258  			var stringLen uint64
 14259  			for shift := uint(0); ; shift += 7 {
 14260  				if shift >= 64 {
 14261  					return ErrIntOverflow
 14262  				}
 14263  				if iNdEx >= l {
 14264  					return io.ErrUnexpectedEOF
 14265  				}
 14266  				b := dAtA[iNdEx]
 14267  				iNdEx++
 14268  				stringLen |= uint64(b&0x7F) << shift
 14269  				if b < 0x80 {
 14270  					break
 14271  				}
 14272  			}
 14273  			intStringLen := int(stringLen)
 14274  			if intStringLen < 0 {
 14275  				return ErrInvalidLength
 14276  			}
 14277  			postIndex := iNdEx + intStringLen
 14278  			if postIndex < 0 {
 14279  				return ErrInvalidLength
 14280  			}
 14281  			if postIndex > l {
 14282  				return io.ErrUnexpectedEOF
 14283  			}
 14284  			m.PostBeginQueries = append(m.PostBeginQueries, string(dAtA[iNdEx:postIndex]))
 14285  			iNdEx = postIndex
 14286  		default:
 14287  			iNdEx = preIndex
 14288  			skippy, err := skip(dAtA[iNdEx:])
 14289  			if err != nil {
 14290  				return err
 14291  			}
 14292  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14293  				return ErrInvalidLength
 14294  			}
 14295  			if (iNdEx + skippy) > l {
 14296  				return io.ErrUnexpectedEOF
 14297  			}
 14298  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14299  			iNdEx += skippy
 14300  		}
 14301  	}
 14302  
 14303  	if iNdEx > l {
 14304  		return io.ErrUnexpectedEOF
 14305  	}
 14306  	return nil
 14307  }
 14308  func (m *ReserveBeginExecuteResponse) UnmarshalVT(dAtA []byte) error {
 14309  	l := len(dAtA)
 14310  	iNdEx := 0
 14311  	for iNdEx < l {
 14312  		preIndex := iNdEx
 14313  		var wire uint64
 14314  		for shift := uint(0); ; shift += 7 {
 14315  			if shift >= 64 {
 14316  				return ErrIntOverflow
 14317  			}
 14318  			if iNdEx >= l {
 14319  				return io.ErrUnexpectedEOF
 14320  			}
 14321  			b := dAtA[iNdEx]
 14322  			iNdEx++
 14323  			wire |= uint64(b&0x7F) << shift
 14324  			if b < 0x80 {
 14325  				break
 14326  			}
 14327  		}
 14328  		fieldNum := int32(wire >> 3)
 14329  		wireType := int(wire & 0x7)
 14330  		if wireType == 4 {
 14331  			return fmt.Errorf("proto: ReserveBeginExecuteResponse: wiretype end group for non-group")
 14332  		}
 14333  		if fieldNum <= 0 {
 14334  			return fmt.Errorf("proto: ReserveBeginExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14335  		}
 14336  		switch fieldNum {
 14337  		case 1:
 14338  			if wireType != 2 {
 14339  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 14340  			}
 14341  			var msglen int
 14342  			for shift := uint(0); ; shift += 7 {
 14343  				if shift >= 64 {
 14344  					return ErrIntOverflow
 14345  				}
 14346  				if iNdEx >= l {
 14347  					return io.ErrUnexpectedEOF
 14348  				}
 14349  				b := dAtA[iNdEx]
 14350  				iNdEx++
 14351  				msglen |= int(b&0x7F) << shift
 14352  				if b < 0x80 {
 14353  					break
 14354  				}
 14355  			}
 14356  			if msglen < 0 {
 14357  				return ErrInvalidLength
 14358  			}
 14359  			postIndex := iNdEx + msglen
 14360  			if postIndex < 0 {
 14361  				return ErrInvalidLength
 14362  			}
 14363  			if postIndex > l {
 14364  				return io.ErrUnexpectedEOF
 14365  			}
 14366  			if m.Error == nil {
 14367  				m.Error = &vtrpc.RPCError{}
 14368  			}
 14369  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14370  				return err
 14371  			}
 14372  			iNdEx = postIndex
 14373  		case 2:
 14374  			if wireType != 2 {
 14375  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 14376  			}
 14377  			var msglen int
 14378  			for shift := uint(0); ; shift += 7 {
 14379  				if shift >= 64 {
 14380  					return ErrIntOverflow
 14381  				}
 14382  				if iNdEx >= l {
 14383  					return io.ErrUnexpectedEOF
 14384  				}
 14385  				b := dAtA[iNdEx]
 14386  				iNdEx++
 14387  				msglen |= int(b&0x7F) << shift
 14388  				if b < 0x80 {
 14389  					break
 14390  				}
 14391  			}
 14392  			if msglen < 0 {
 14393  				return ErrInvalidLength
 14394  			}
 14395  			postIndex := iNdEx + msglen
 14396  			if postIndex < 0 {
 14397  				return ErrInvalidLength
 14398  			}
 14399  			if postIndex > l {
 14400  				return io.ErrUnexpectedEOF
 14401  			}
 14402  			if m.Result == nil {
 14403  				m.Result = &QueryResult{}
 14404  			}
 14405  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14406  				return err
 14407  			}
 14408  			iNdEx = postIndex
 14409  		case 3:
 14410  			if wireType != 0 {
 14411  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 14412  			}
 14413  			m.TransactionId = 0
 14414  			for shift := uint(0); ; shift += 7 {
 14415  				if shift >= 64 {
 14416  					return ErrIntOverflow
 14417  				}
 14418  				if iNdEx >= l {
 14419  					return io.ErrUnexpectedEOF
 14420  				}
 14421  				b := dAtA[iNdEx]
 14422  				iNdEx++
 14423  				m.TransactionId |= int64(b&0x7F) << shift
 14424  				if b < 0x80 {
 14425  					break
 14426  				}
 14427  			}
 14428  		case 4:
 14429  			if wireType != 0 {
 14430  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 14431  			}
 14432  			m.ReservedId = 0
 14433  			for shift := uint(0); ; shift += 7 {
 14434  				if shift >= 64 {
 14435  					return ErrIntOverflow
 14436  				}
 14437  				if iNdEx >= l {
 14438  					return io.ErrUnexpectedEOF
 14439  				}
 14440  				b := dAtA[iNdEx]
 14441  				iNdEx++
 14442  				m.ReservedId |= int64(b&0x7F) << shift
 14443  				if b < 0x80 {
 14444  					break
 14445  				}
 14446  			}
 14447  		case 5:
 14448  			if wireType != 2 {
 14449  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 14450  			}
 14451  			var msglen int
 14452  			for shift := uint(0); ; shift += 7 {
 14453  				if shift >= 64 {
 14454  					return ErrIntOverflow
 14455  				}
 14456  				if iNdEx >= l {
 14457  					return io.ErrUnexpectedEOF
 14458  				}
 14459  				b := dAtA[iNdEx]
 14460  				iNdEx++
 14461  				msglen |= int(b&0x7F) << shift
 14462  				if b < 0x80 {
 14463  					break
 14464  				}
 14465  			}
 14466  			if msglen < 0 {
 14467  				return ErrInvalidLength
 14468  			}
 14469  			postIndex := iNdEx + msglen
 14470  			if postIndex < 0 {
 14471  				return ErrInvalidLength
 14472  			}
 14473  			if postIndex > l {
 14474  				return io.ErrUnexpectedEOF
 14475  			}
 14476  			if m.TabletAlias == nil {
 14477  				m.TabletAlias = &topodata.TabletAlias{}
 14478  			}
 14479  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14480  				return err
 14481  			}
 14482  			iNdEx = postIndex
 14483  		default:
 14484  			iNdEx = preIndex
 14485  			skippy, err := skip(dAtA[iNdEx:])
 14486  			if err != nil {
 14487  				return err
 14488  			}
 14489  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14490  				return ErrInvalidLength
 14491  			}
 14492  			if (iNdEx + skippy) > l {
 14493  				return io.ErrUnexpectedEOF
 14494  			}
 14495  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14496  			iNdEx += skippy
 14497  		}
 14498  	}
 14499  
 14500  	if iNdEx > l {
 14501  		return io.ErrUnexpectedEOF
 14502  	}
 14503  	return nil
 14504  }
 14505  func (m *ReserveBeginStreamExecuteRequest) UnmarshalVT(dAtA []byte) error {
 14506  	l := len(dAtA)
 14507  	iNdEx := 0
 14508  	for iNdEx < l {
 14509  		preIndex := iNdEx
 14510  		var wire uint64
 14511  		for shift := uint(0); ; shift += 7 {
 14512  			if shift >= 64 {
 14513  				return ErrIntOverflow
 14514  			}
 14515  			if iNdEx >= l {
 14516  				return io.ErrUnexpectedEOF
 14517  			}
 14518  			b := dAtA[iNdEx]
 14519  			iNdEx++
 14520  			wire |= uint64(b&0x7F) << shift
 14521  			if b < 0x80 {
 14522  				break
 14523  			}
 14524  		}
 14525  		fieldNum := int32(wire >> 3)
 14526  		wireType := int(wire & 0x7)
 14527  		if wireType == 4 {
 14528  			return fmt.Errorf("proto: ReserveBeginStreamExecuteRequest: wiretype end group for non-group")
 14529  		}
 14530  		if fieldNum <= 0 {
 14531  			return fmt.Errorf("proto: ReserveBeginStreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14532  		}
 14533  		switch fieldNum {
 14534  		case 1:
 14535  			if wireType != 2 {
 14536  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 14537  			}
 14538  			var msglen int
 14539  			for shift := uint(0); ; shift += 7 {
 14540  				if shift >= 64 {
 14541  					return ErrIntOverflow
 14542  				}
 14543  				if iNdEx >= l {
 14544  					return io.ErrUnexpectedEOF
 14545  				}
 14546  				b := dAtA[iNdEx]
 14547  				iNdEx++
 14548  				msglen |= int(b&0x7F) << shift
 14549  				if b < 0x80 {
 14550  					break
 14551  				}
 14552  			}
 14553  			if msglen < 0 {
 14554  				return ErrInvalidLength
 14555  			}
 14556  			postIndex := iNdEx + msglen
 14557  			if postIndex < 0 {
 14558  				return ErrInvalidLength
 14559  			}
 14560  			if postIndex > l {
 14561  				return io.ErrUnexpectedEOF
 14562  			}
 14563  			if m.EffectiveCallerId == nil {
 14564  				m.EffectiveCallerId = &vtrpc.CallerID{}
 14565  			}
 14566  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14567  				return err
 14568  			}
 14569  			iNdEx = postIndex
 14570  		case 2:
 14571  			if wireType != 2 {
 14572  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 14573  			}
 14574  			var msglen int
 14575  			for shift := uint(0); ; shift += 7 {
 14576  				if shift >= 64 {
 14577  					return ErrIntOverflow
 14578  				}
 14579  				if iNdEx >= l {
 14580  					return io.ErrUnexpectedEOF
 14581  				}
 14582  				b := dAtA[iNdEx]
 14583  				iNdEx++
 14584  				msglen |= int(b&0x7F) << shift
 14585  				if b < 0x80 {
 14586  					break
 14587  				}
 14588  			}
 14589  			if msglen < 0 {
 14590  				return ErrInvalidLength
 14591  			}
 14592  			postIndex := iNdEx + msglen
 14593  			if postIndex < 0 {
 14594  				return ErrInvalidLength
 14595  			}
 14596  			if postIndex > l {
 14597  				return io.ErrUnexpectedEOF
 14598  			}
 14599  			if m.ImmediateCallerId == nil {
 14600  				m.ImmediateCallerId = &VTGateCallerID{}
 14601  			}
 14602  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14603  				return err
 14604  			}
 14605  			iNdEx = postIndex
 14606  		case 3:
 14607  			if wireType != 2 {
 14608  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 14609  			}
 14610  			var msglen int
 14611  			for shift := uint(0); ; shift += 7 {
 14612  				if shift >= 64 {
 14613  					return ErrIntOverflow
 14614  				}
 14615  				if iNdEx >= l {
 14616  					return io.ErrUnexpectedEOF
 14617  				}
 14618  				b := dAtA[iNdEx]
 14619  				iNdEx++
 14620  				msglen |= int(b&0x7F) << shift
 14621  				if b < 0x80 {
 14622  					break
 14623  				}
 14624  			}
 14625  			if msglen < 0 {
 14626  				return ErrInvalidLength
 14627  			}
 14628  			postIndex := iNdEx + msglen
 14629  			if postIndex < 0 {
 14630  				return ErrInvalidLength
 14631  			}
 14632  			if postIndex > l {
 14633  				return io.ErrUnexpectedEOF
 14634  			}
 14635  			if m.Target == nil {
 14636  				m.Target = &Target{}
 14637  			}
 14638  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14639  				return err
 14640  			}
 14641  			iNdEx = postIndex
 14642  		case 4:
 14643  			if wireType != 2 {
 14644  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 14645  			}
 14646  			var msglen int
 14647  			for shift := uint(0); ; shift += 7 {
 14648  				if shift >= 64 {
 14649  					return ErrIntOverflow
 14650  				}
 14651  				if iNdEx >= l {
 14652  					return io.ErrUnexpectedEOF
 14653  				}
 14654  				b := dAtA[iNdEx]
 14655  				iNdEx++
 14656  				msglen |= int(b&0x7F) << shift
 14657  				if b < 0x80 {
 14658  					break
 14659  				}
 14660  			}
 14661  			if msglen < 0 {
 14662  				return ErrInvalidLength
 14663  			}
 14664  			postIndex := iNdEx + msglen
 14665  			if postIndex < 0 {
 14666  				return ErrInvalidLength
 14667  			}
 14668  			if postIndex > l {
 14669  				return io.ErrUnexpectedEOF
 14670  			}
 14671  			if m.Query == nil {
 14672  				m.Query = &BoundQuery{}
 14673  			}
 14674  			if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14675  				return err
 14676  			}
 14677  			iNdEx = postIndex
 14678  		case 5:
 14679  			if wireType != 2 {
 14680  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 14681  			}
 14682  			var msglen int
 14683  			for shift := uint(0); ; shift += 7 {
 14684  				if shift >= 64 {
 14685  					return ErrIntOverflow
 14686  				}
 14687  				if iNdEx >= l {
 14688  					return io.ErrUnexpectedEOF
 14689  				}
 14690  				b := dAtA[iNdEx]
 14691  				iNdEx++
 14692  				msglen |= int(b&0x7F) << shift
 14693  				if b < 0x80 {
 14694  					break
 14695  				}
 14696  			}
 14697  			if msglen < 0 {
 14698  				return ErrInvalidLength
 14699  			}
 14700  			postIndex := iNdEx + msglen
 14701  			if postIndex < 0 {
 14702  				return ErrInvalidLength
 14703  			}
 14704  			if postIndex > l {
 14705  				return io.ErrUnexpectedEOF
 14706  			}
 14707  			if m.Options == nil {
 14708  				m.Options = &ExecuteOptions{}
 14709  			}
 14710  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14711  				return err
 14712  			}
 14713  			iNdEx = postIndex
 14714  		case 6:
 14715  			if wireType != 2 {
 14716  				return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType)
 14717  			}
 14718  			var stringLen uint64
 14719  			for shift := uint(0); ; shift += 7 {
 14720  				if shift >= 64 {
 14721  					return ErrIntOverflow
 14722  				}
 14723  				if iNdEx >= l {
 14724  					return io.ErrUnexpectedEOF
 14725  				}
 14726  				b := dAtA[iNdEx]
 14727  				iNdEx++
 14728  				stringLen |= uint64(b&0x7F) << shift
 14729  				if b < 0x80 {
 14730  					break
 14731  				}
 14732  			}
 14733  			intStringLen := int(stringLen)
 14734  			if intStringLen < 0 {
 14735  				return ErrInvalidLength
 14736  			}
 14737  			postIndex := iNdEx + intStringLen
 14738  			if postIndex < 0 {
 14739  				return ErrInvalidLength
 14740  			}
 14741  			if postIndex > l {
 14742  				return io.ErrUnexpectedEOF
 14743  			}
 14744  			m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex]))
 14745  			iNdEx = postIndex
 14746  		case 7:
 14747  			if wireType != 2 {
 14748  				return fmt.Errorf("proto: wrong wireType = %d for field PostBeginQueries", wireType)
 14749  			}
 14750  			var stringLen uint64
 14751  			for shift := uint(0); ; shift += 7 {
 14752  				if shift >= 64 {
 14753  					return ErrIntOverflow
 14754  				}
 14755  				if iNdEx >= l {
 14756  					return io.ErrUnexpectedEOF
 14757  				}
 14758  				b := dAtA[iNdEx]
 14759  				iNdEx++
 14760  				stringLen |= uint64(b&0x7F) << shift
 14761  				if b < 0x80 {
 14762  					break
 14763  				}
 14764  			}
 14765  			intStringLen := int(stringLen)
 14766  			if intStringLen < 0 {
 14767  				return ErrInvalidLength
 14768  			}
 14769  			postIndex := iNdEx + intStringLen
 14770  			if postIndex < 0 {
 14771  				return ErrInvalidLength
 14772  			}
 14773  			if postIndex > l {
 14774  				return io.ErrUnexpectedEOF
 14775  			}
 14776  			m.PostBeginQueries = append(m.PostBeginQueries, string(dAtA[iNdEx:postIndex]))
 14777  			iNdEx = postIndex
 14778  		default:
 14779  			iNdEx = preIndex
 14780  			skippy, err := skip(dAtA[iNdEx:])
 14781  			if err != nil {
 14782  				return err
 14783  			}
 14784  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14785  				return ErrInvalidLength
 14786  			}
 14787  			if (iNdEx + skippy) > l {
 14788  				return io.ErrUnexpectedEOF
 14789  			}
 14790  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14791  			iNdEx += skippy
 14792  		}
 14793  	}
 14794  
 14795  	if iNdEx > l {
 14796  		return io.ErrUnexpectedEOF
 14797  	}
 14798  	return nil
 14799  }
 14800  func (m *ReserveBeginStreamExecuteResponse) UnmarshalVT(dAtA []byte) error {
 14801  	l := len(dAtA)
 14802  	iNdEx := 0
 14803  	for iNdEx < l {
 14804  		preIndex := iNdEx
 14805  		var wire uint64
 14806  		for shift := uint(0); ; shift += 7 {
 14807  			if shift >= 64 {
 14808  				return ErrIntOverflow
 14809  			}
 14810  			if iNdEx >= l {
 14811  				return io.ErrUnexpectedEOF
 14812  			}
 14813  			b := dAtA[iNdEx]
 14814  			iNdEx++
 14815  			wire |= uint64(b&0x7F) << shift
 14816  			if b < 0x80 {
 14817  				break
 14818  			}
 14819  		}
 14820  		fieldNum := int32(wire >> 3)
 14821  		wireType := int(wire & 0x7)
 14822  		if wireType == 4 {
 14823  			return fmt.Errorf("proto: ReserveBeginStreamExecuteResponse: wiretype end group for non-group")
 14824  		}
 14825  		if fieldNum <= 0 {
 14826  			return fmt.Errorf("proto: ReserveBeginStreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14827  		}
 14828  		switch fieldNum {
 14829  		case 1:
 14830  			if wireType != 2 {
 14831  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
 14832  			}
 14833  			var msglen int
 14834  			for shift := uint(0); ; shift += 7 {
 14835  				if shift >= 64 {
 14836  					return ErrIntOverflow
 14837  				}
 14838  				if iNdEx >= l {
 14839  					return io.ErrUnexpectedEOF
 14840  				}
 14841  				b := dAtA[iNdEx]
 14842  				iNdEx++
 14843  				msglen |= int(b&0x7F) << shift
 14844  				if b < 0x80 {
 14845  					break
 14846  				}
 14847  			}
 14848  			if msglen < 0 {
 14849  				return ErrInvalidLength
 14850  			}
 14851  			postIndex := iNdEx + msglen
 14852  			if postIndex < 0 {
 14853  				return ErrInvalidLength
 14854  			}
 14855  			if postIndex > l {
 14856  				return io.ErrUnexpectedEOF
 14857  			}
 14858  			if m.Error == nil {
 14859  				m.Error = &vtrpc.RPCError{}
 14860  			}
 14861  			if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14862  				return err
 14863  			}
 14864  			iNdEx = postIndex
 14865  		case 2:
 14866  			if wireType != 2 {
 14867  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 14868  			}
 14869  			var msglen int
 14870  			for shift := uint(0); ; shift += 7 {
 14871  				if shift >= 64 {
 14872  					return ErrIntOverflow
 14873  				}
 14874  				if iNdEx >= l {
 14875  					return io.ErrUnexpectedEOF
 14876  				}
 14877  				b := dAtA[iNdEx]
 14878  				iNdEx++
 14879  				msglen |= int(b&0x7F) << shift
 14880  				if b < 0x80 {
 14881  					break
 14882  				}
 14883  			}
 14884  			if msglen < 0 {
 14885  				return ErrInvalidLength
 14886  			}
 14887  			postIndex := iNdEx + msglen
 14888  			if postIndex < 0 {
 14889  				return ErrInvalidLength
 14890  			}
 14891  			if postIndex > l {
 14892  				return io.ErrUnexpectedEOF
 14893  			}
 14894  			if m.Result == nil {
 14895  				m.Result = &QueryResult{}
 14896  			}
 14897  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14898  				return err
 14899  			}
 14900  			iNdEx = postIndex
 14901  		case 3:
 14902  			if wireType != 0 {
 14903  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 14904  			}
 14905  			m.TransactionId = 0
 14906  			for shift := uint(0); ; shift += 7 {
 14907  				if shift >= 64 {
 14908  					return ErrIntOverflow
 14909  				}
 14910  				if iNdEx >= l {
 14911  					return io.ErrUnexpectedEOF
 14912  				}
 14913  				b := dAtA[iNdEx]
 14914  				iNdEx++
 14915  				m.TransactionId |= int64(b&0x7F) << shift
 14916  				if b < 0x80 {
 14917  					break
 14918  				}
 14919  			}
 14920  		case 4:
 14921  			if wireType != 0 {
 14922  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 14923  			}
 14924  			m.ReservedId = 0
 14925  			for shift := uint(0); ; shift += 7 {
 14926  				if shift >= 64 {
 14927  					return ErrIntOverflow
 14928  				}
 14929  				if iNdEx >= l {
 14930  					return io.ErrUnexpectedEOF
 14931  				}
 14932  				b := dAtA[iNdEx]
 14933  				iNdEx++
 14934  				m.ReservedId |= int64(b&0x7F) << shift
 14935  				if b < 0x80 {
 14936  					break
 14937  				}
 14938  			}
 14939  		case 5:
 14940  			if wireType != 2 {
 14941  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 14942  			}
 14943  			var msglen int
 14944  			for shift := uint(0); ; shift += 7 {
 14945  				if shift >= 64 {
 14946  					return ErrIntOverflow
 14947  				}
 14948  				if iNdEx >= l {
 14949  					return io.ErrUnexpectedEOF
 14950  				}
 14951  				b := dAtA[iNdEx]
 14952  				iNdEx++
 14953  				msglen |= int(b&0x7F) << shift
 14954  				if b < 0x80 {
 14955  					break
 14956  				}
 14957  			}
 14958  			if msglen < 0 {
 14959  				return ErrInvalidLength
 14960  			}
 14961  			postIndex := iNdEx + msglen
 14962  			if postIndex < 0 {
 14963  				return ErrInvalidLength
 14964  			}
 14965  			if postIndex > l {
 14966  				return io.ErrUnexpectedEOF
 14967  			}
 14968  			if m.TabletAlias == nil {
 14969  				m.TabletAlias = &topodata.TabletAlias{}
 14970  			}
 14971  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14972  				return err
 14973  			}
 14974  			iNdEx = postIndex
 14975  		default:
 14976  			iNdEx = preIndex
 14977  			skippy, err := skip(dAtA[iNdEx:])
 14978  			if err != nil {
 14979  				return err
 14980  			}
 14981  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14982  				return ErrInvalidLength
 14983  			}
 14984  			if (iNdEx + skippy) > l {
 14985  				return io.ErrUnexpectedEOF
 14986  			}
 14987  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14988  			iNdEx += skippy
 14989  		}
 14990  	}
 14991  
 14992  	if iNdEx > l {
 14993  		return io.ErrUnexpectedEOF
 14994  	}
 14995  	return nil
 14996  }
 14997  func (m *ReleaseRequest) UnmarshalVT(dAtA []byte) error {
 14998  	l := len(dAtA)
 14999  	iNdEx := 0
 15000  	for iNdEx < l {
 15001  		preIndex := iNdEx
 15002  		var wire uint64
 15003  		for shift := uint(0); ; shift += 7 {
 15004  			if shift >= 64 {
 15005  				return ErrIntOverflow
 15006  			}
 15007  			if iNdEx >= l {
 15008  				return io.ErrUnexpectedEOF
 15009  			}
 15010  			b := dAtA[iNdEx]
 15011  			iNdEx++
 15012  			wire |= uint64(b&0x7F) << shift
 15013  			if b < 0x80 {
 15014  				break
 15015  			}
 15016  		}
 15017  		fieldNum := int32(wire >> 3)
 15018  		wireType := int(wire & 0x7)
 15019  		if wireType == 4 {
 15020  			return fmt.Errorf("proto: ReleaseRequest: wiretype end group for non-group")
 15021  		}
 15022  		if fieldNum <= 0 {
 15023  			return fmt.Errorf("proto: ReleaseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15024  		}
 15025  		switch fieldNum {
 15026  		case 1:
 15027  			if wireType != 2 {
 15028  				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType)
 15029  			}
 15030  			var msglen int
 15031  			for shift := uint(0); ; shift += 7 {
 15032  				if shift >= 64 {
 15033  					return ErrIntOverflow
 15034  				}
 15035  				if iNdEx >= l {
 15036  					return io.ErrUnexpectedEOF
 15037  				}
 15038  				b := dAtA[iNdEx]
 15039  				iNdEx++
 15040  				msglen |= int(b&0x7F) << shift
 15041  				if b < 0x80 {
 15042  					break
 15043  				}
 15044  			}
 15045  			if msglen < 0 {
 15046  				return ErrInvalidLength
 15047  			}
 15048  			postIndex := iNdEx + msglen
 15049  			if postIndex < 0 {
 15050  				return ErrInvalidLength
 15051  			}
 15052  			if postIndex > l {
 15053  				return io.ErrUnexpectedEOF
 15054  			}
 15055  			if m.EffectiveCallerId == nil {
 15056  				m.EffectiveCallerId = &vtrpc.CallerID{}
 15057  			}
 15058  			if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15059  				return err
 15060  			}
 15061  			iNdEx = postIndex
 15062  		case 2:
 15063  			if wireType != 2 {
 15064  				return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType)
 15065  			}
 15066  			var msglen int
 15067  			for shift := uint(0); ; shift += 7 {
 15068  				if shift >= 64 {
 15069  					return ErrIntOverflow
 15070  				}
 15071  				if iNdEx >= l {
 15072  					return io.ErrUnexpectedEOF
 15073  				}
 15074  				b := dAtA[iNdEx]
 15075  				iNdEx++
 15076  				msglen |= int(b&0x7F) << shift
 15077  				if b < 0x80 {
 15078  					break
 15079  				}
 15080  			}
 15081  			if msglen < 0 {
 15082  				return ErrInvalidLength
 15083  			}
 15084  			postIndex := iNdEx + msglen
 15085  			if postIndex < 0 {
 15086  				return ErrInvalidLength
 15087  			}
 15088  			if postIndex > l {
 15089  				return io.ErrUnexpectedEOF
 15090  			}
 15091  			if m.ImmediateCallerId == nil {
 15092  				m.ImmediateCallerId = &VTGateCallerID{}
 15093  			}
 15094  			if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15095  				return err
 15096  			}
 15097  			iNdEx = postIndex
 15098  		case 3:
 15099  			if wireType != 2 {
 15100  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 15101  			}
 15102  			var msglen int
 15103  			for shift := uint(0); ; shift += 7 {
 15104  				if shift >= 64 {
 15105  					return ErrIntOverflow
 15106  				}
 15107  				if iNdEx >= l {
 15108  					return io.ErrUnexpectedEOF
 15109  				}
 15110  				b := dAtA[iNdEx]
 15111  				iNdEx++
 15112  				msglen |= int(b&0x7F) << shift
 15113  				if b < 0x80 {
 15114  					break
 15115  				}
 15116  			}
 15117  			if msglen < 0 {
 15118  				return ErrInvalidLength
 15119  			}
 15120  			postIndex := iNdEx + msglen
 15121  			if postIndex < 0 {
 15122  				return ErrInvalidLength
 15123  			}
 15124  			if postIndex > l {
 15125  				return io.ErrUnexpectedEOF
 15126  			}
 15127  			if m.Target == nil {
 15128  				m.Target = &Target{}
 15129  			}
 15130  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15131  				return err
 15132  			}
 15133  			iNdEx = postIndex
 15134  		case 4:
 15135  			if wireType != 0 {
 15136  				return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
 15137  			}
 15138  			m.TransactionId = 0
 15139  			for shift := uint(0); ; shift += 7 {
 15140  				if shift >= 64 {
 15141  					return ErrIntOverflow
 15142  				}
 15143  				if iNdEx >= l {
 15144  					return io.ErrUnexpectedEOF
 15145  				}
 15146  				b := dAtA[iNdEx]
 15147  				iNdEx++
 15148  				m.TransactionId |= int64(b&0x7F) << shift
 15149  				if b < 0x80 {
 15150  					break
 15151  				}
 15152  			}
 15153  		case 5:
 15154  			if wireType != 0 {
 15155  				return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType)
 15156  			}
 15157  			m.ReservedId = 0
 15158  			for shift := uint(0); ; shift += 7 {
 15159  				if shift >= 64 {
 15160  					return ErrIntOverflow
 15161  				}
 15162  				if iNdEx >= l {
 15163  					return io.ErrUnexpectedEOF
 15164  				}
 15165  				b := dAtA[iNdEx]
 15166  				iNdEx++
 15167  				m.ReservedId |= int64(b&0x7F) << shift
 15168  				if b < 0x80 {
 15169  					break
 15170  				}
 15171  			}
 15172  		default:
 15173  			iNdEx = preIndex
 15174  			skippy, err := skip(dAtA[iNdEx:])
 15175  			if err != nil {
 15176  				return err
 15177  			}
 15178  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15179  				return ErrInvalidLength
 15180  			}
 15181  			if (iNdEx + skippy) > l {
 15182  				return io.ErrUnexpectedEOF
 15183  			}
 15184  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15185  			iNdEx += skippy
 15186  		}
 15187  	}
 15188  
 15189  	if iNdEx > l {
 15190  		return io.ErrUnexpectedEOF
 15191  	}
 15192  	return nil
 15193  }
 15194  func (m *ReleaseResponse) UnmarshalVT(dAtA []byte) error {
 15195  	l := len(dAtA)
 15196  	iNdEx := 0
 15197  	for iNdEx < l {
 15198  		preIndex := iNdEx
 15199  		var wire uint64
 15200  		for shift := uint(0); ; shift += 7 {
 15201  			if shift >= 64 {
 15202  				return ErrIntOverflow
 15203  			}
 15204  			if iNdEx >= l {
 15205  				return io.ErrUnexpectedEOF
 15206  			}
 15207  			b := dAtA[iNdEx]
 15208  			iNdEx++
 15209  			wire |= uint64(b&0x7F) << shift
 15210  			if b < 0x80 {
 15211  				break
 15212  			}
 15213  		}
 15214  		fieldNum := int32(wire >> 3)
 15215  		wireType := int(wire & 0x7)
 15216  		if wireType == 4 {
 15217  			return fmt.Errorf("proto: ReleaseResponse: wiretype end group for non-group")
 15218  		}
 15219  		if fieldNum <= 0 {
 15220  			return fmt.Errorf("proto: ReleaseResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15221  		}
 15222  		switch fieldNum {
 15223  		default:
 15224  			iNdEx = preIndex
 15225  			skippy, err := skip(dAtA[iNdEx:])
 15226  			if err != nil {
 15227  				return err
 15228  			}
 15229  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15230  				return ErrInvalidLength
 15231  			}
 15232  			if (iNdEx + skippy) > l {
 15233  				return io.ErrUnexpectedEOF
 15234  			}
 15235  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15236  			iNdEx += skippy
 15237  		}
 15238  	}
 15239  
 15240  	if iNdEx > l {
 15241  		return io.ErrUnexpectedEOF
 15242  	}
 15243  	return nil
 15244  }
 15245  func (m *StreamHealthRequest) UnmarshalVT(dAtA []byte) error {
 15246  	l := len(dAtA)
 15247  	iNdEx := 0
 15248  	for iNdEx < l {
 15249  		preIndex := iNdEx
 15250  		var wire uint64
 15251  		for shift := uint(0); ; shift += 7 {
 15252  			if shift >= 64 {
 15253  				return ErrIntOverflow
 15254  			}
 15255  			if iNdEx >= l {
 15256  				return io.ErrUnexpectedEOF
 15257  			}
 15258  			b := dAtA[iNdEx]
 15259  			iNdEx++
 15260  			wire |= uint64(b&0x7F) << shift
 15261  			if b < 0x80 {
 15262  				break
 15263  			}
 15264  		}
 15265  		fieldNum := int32(wire >> 3)
 15266  		wireType := int(wire & 0x7)
 15267  		if wireType == 4 {
 15268  			return fmt.Errorf("proto: StreamHealthRequest: wiretype end group for non-group")
 15269  		}
 15270  		if fieldNum <= 0 {
 15271  			return fmt.Errorf("proto: StreamHealthRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15272  		}
 15273  		switch fieldNum {
 15274  		default:
 15275  			iNdEx = preIndex
 15276  			skippy, err := skip(dAtA[iNdEx:])
 15277  			if err != nil {
 15278  				return err
 15279  			}
 15280  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15281  				return ErrInvalidLength
 15282  			}
 15283  			if (iNdEx + skippy) > l {
 15284  				return io.ErrUnexpectedEOF
 15285  			}
 15286  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15287  			iNdEx += skippy
 15288  		}
 15289  	}
 15290  
 15291  	if iNdEx > l {
 15292  		return io.ErrUnexpectedEOF
 15293  	}
 15294  	return nil
 15295  }
 15296  func (m *RealtimeStats) UnmarshalVT(dAtA []byte) error {
 15297  	l := len(dAtA)
 15298  	iNdEx := 0
 15299  	for iNdEx < l {
 15300  		preIndex := iNdEx
 15301  		var wire uint64
 15302  		for shift := uint(0); ; shift += 7 {
 15303  			if shift >= 64 {
 15304  				return ErrIntOverflow
 15305  			}
 15306  			if iNdEx >= l {
 15307  				return io.ErrUnexpectedEOF
 15308  			}
 15309  			b := dAtA[iNdEx]
 15310  			iNdEx++
 15311  			wire |= uint64(b&0x7F) << shift
 15312  			if b < 0x80 {
 15313  				break
 15314  			}
 15315  		}
 15316  		fieldNum := int32(wire >> 3)
 15317  		wireType := int(wire & 0x7)
 15318  		if wireType == 4 {
 15319  			return fmt.Errorf("proto: RealtimeStats: wiretype end group for non-group")
 15320  		}
 15321  		if fieldNum <= 0 {
 15322  			return fmt.Errorf("proto: RealtimeStats: illegal tag %d (wire type %d)", fieldNum, wire)
 15323  		}
 15324  		switch fieldNum {
 15325  		case 1:
 15326  			if wireType != 2 {
 15327  				return fmt.Errorf("proto: wrong wireType = %d for field HealthError", wireType)
 15328  			}
 15329  			var stringLen uint64
 15330  			for shift := uint(0); ; shift += 7 {
 15331  				if shift >= 64 {
 15332  					return ErrIntOverflow
 15333  				}
 15334  				if iNdEx >= l {
 15335  					return io.ErrUnexpectedEOF
 15336  				}
 15337  				b := dAtA[iNdEx]
 15338  				iNdEx++
 15339  				stringLen |= uint64(b&0x7F) << shift
 15340  				if b < 0x80 {
 15341  					break
 15342  				}
 15343  			}
 15344  			intStringLen := int(stringLen)
 15345  			if intStringLen < 0 {
 15346  				return ErrInvalidLength
 15347  			}
 15348  			postIndex := iNdEx + intStringLen
 15349  			if postIndex < 0 {
 15350  				return ErrInvalidLength
 15351  			}
 15352  			if postIndex > l {
 15353  				return io.ErrUnexpectedEOF
 15354  			}
 15355  			m.HealthError = string(dAtA[iNdEx:postIndex])
 15356  			iNdEx = postIndex
 15357  		case 2:
 15358  			if wireType != 0 {
 15359  				return fmt.Errorf("proto: wrong wireType = %d for field ReplicationLagSeconds", wireType)
 15360  			}
 15361  			m.ReplicationLagSeconds = 0
 15362  			for shift := uint(0); ; shift += 7 {
 15363  				if shift >= 64 {
 15364  					return ErrIntOverflow
 15365  				}
 15366  				if iNdEx >= l {
 15367  					return io.ErrUnexpectedEOF
 15368  				}
 15369  				b := dAtA[iNdEx]
 15370  				iNdEx++
 15371  				m.ReplicationLagSeconds |= uint32(b&0x7F) << shift
 15372  				if b < 0x80 {
 15373  					break
 15374  				}
 15375  			}
 15376  		case 3:
 15377  			if wireType != 0 {
 15378  				return fmt.Errorf("proto: wrong wireType = %d for field BinlogPlayersCount", wireType)
 15379  			}
 15380  			m.BinlogPlayersCount = 0
 15381  			for shift := uint(0); ; shift += 7 {
 15382  				if shift >= 64 {
 15383  					return ErrIntOverflow
 15384  				}
 15385  				if iNdEx >= l {
 15386  					return io.ErrUnexpectedEOF
 15387  				}
 15388  				b := dAtA[iNdEx]
 15389  				iNdEx++
 15390  				m.BinlogPlayersCount |= int32(b&0x7F) << shift
 15391  				if b < 0x80 {
 15392  					break
 15393  				}
 15394  			}
 15395  		case 4:
 15396  			if wireType != 0 {
 15397  				return fmt.Errorf("proto: wrong wireType = %d for field FilteredReplicationLagSeconds", wireType)
 15398  			}
 15399  			m.FilteredReplicationLagSeconds = 0
 15400  			for shift := uint(0); ; shift += 7 {
 15401  				if shift >= 64 {
 15402  					return ErrIntOverflow
 15403  				}
 15404  				if iNdEx >= l {
 15405  					return io.ErrUnexpectedEOF
 15406  				}
 15407  				b := dAtA[iNdEx]
 15408  				iNdEx++
 15409  				m.FilteredReplicationLagSeconds |= int64(b&0x7F) << shift
 15410  				if b < 0x80 {
 15411  					break
 15412  				}
 15413  			}
 15414  		case 5:
 15415  			if wireType != 1 {
 15416  				return fmt.Errorf("proto: wrong wireType = %d for field CpuUsage", wireType)
 15417  			}
 15418  			var v uint64
 15419  			if (iNdEx + 8) > l {
 15420  				return io.ErrUnexpectedEOF
 15421  			}
 15422  			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 15423  			iNdEx += 8
 15424  			m.CpuUsage = float64(math.Float64frombits(v))
 15425  		case 6:
 15426  			if wireType != 1 {
 15427  				return fmt.Errorf("proto: wrong wireType = %d for field Qps", wireType)
 15428  			}
 15429  			var v uint64
 15430  			if (iNdEx + 8) > l {
 15431  				return io.ErrUnexpectedEOF
 15432  			}
 15433  			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
 15434  			iNdEx += 8
 15435  			m.Qps = float64(math.Float64frombits(v))
 15436  		case 7:
 15437  			if wireType != 2 {
 15438  				return fmt.Errorf("proto: wrong wireType = %d for field TableSchemaChanged", wireType)
 15439  			}
 15440  			var stringLen uint64
 15441  			for shift := uint(0); ; shift += 7 {
 15442  				if shift >= 64 {
 15443  					return ErrIntOverflow
 15444  				}
 15445  				if iNdEx >= l {
 15446  					return io.ErrUnexpectedEOF
 15447  				}
 15448  				b := dAtA[iNdEx]
 15449  				iNdEx++
 15450  				stringLen |= uint64(b&0x7F) << shift
 15451  				if b < 0x80 {
 15452  					break
 15453  				}
 15454  			}
 15455  			intStringLen := int(stringLen)
 15456  			if intStringLen < 0 {
 15457  				return ErrInvalidLength
 15458  			}
 15459  			postIndex := iNdEx + intStringLen
 15460  			if postIndex < 0 {
 15461  				return ErrInvalidLength
 15462  			}
 15463  			if postIndex > l {
 15464  				return io.ErrUnexpectedEOF
 15465  			}
 15466  			m.TableSchemaChanged = append(m.TableSchemaChanged, string(dAtA[iNdEx:postIndex]))
 15467  			iNdEx = postIndex
 15468  		default:
 15469  			iNdEx = preIndex
 15470  			skippy, err := skip(dAtA[iNdEx:])
 15471  			if err != nil {
 15472  				return err
 15473  			}
 15474  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15475  				return ErrInvalidLength
 15476  			}
 15477  			if (iNdEx + skippy) > l {
 15478  				return io.ErrUnexpectedEOF
 15479  			}
 15480  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15481  			iNdEx += skippy
 15482  		}
 15483  	}
 15484  
 15485  	if iNdEx > l {
 15486  		return io.ErrUnexpectedEOF
 15487  	}
 15488  	return nil
 15489  }
 15490  func (m *AggregateStats) UnmarshalVT(dAtA []byte) error {
 15491  	l := len(dAtA)
 15492  	iNdEx := 0
 15493  	for iNdEx < l {
 15494  		preIndex := iNdEx
 15495  		var wire uint64
 15496  		for shift := uint(0); ; shift += 7 {
 15497  			if shift >= 64 {
 15498  				return ErrIntOverflow
 15499  			}
 15500  			if iNdEx >= l {
 15501  				return io.ErrUnexpectedEOF
 15502  			}
 15503  			b := dAtA[iNdEx]
 15504  			iNdEx++
 15505  			wire |= uint64(b&0x7F) << shift
 15506  			if b < 0x80 {
 15507  				break
 15508  			}
 15509  		}
 15510  		fieldNum := int32(wire >> 3)
 15511  		wireType := int(wire & 0x7)
 15512  		if wireType == 4 {
 15513  			return fmt.Errorf("proto: AggregateStats: wiretype end group for non-group")
 15514  		}
 15515  		if fieldNum <= 0 {
 15516  			return fmt.Errorf("proto: AggregateStats: illegal tag %d (wire type %d)", fieldNum, wire)
 15517  		}
 15518  		switch fieldNum {
 15519  		case 1:
 15520  			if wireType != 0 {
 15521  				return fmt.Errorf("proto: wrong wireType = %d for field HealthyTabletCount", wireType)
 15522  			}
 15523  			m.HealthyTabletCount = 0
 15524  			for shift := uint(0); ; shift += 7 {
 15525  				if shift >= 64 {
 15526  					return ErrIntOverflow
 15527  				}
 15528  				if iNdEx >= l {
 15529  					return io.ErrUnexpectedEOF
 15530  				}
 15531  				b := dAtA[iNdEx]
 15532  				iNdEx++
 15533  				m.HealthyTabletCount |= int32(b&0x7F) << shift
 15534  				if b < 0x80 {
 15535  					break
 15536  				}
 15537  			}
 15538  		case 2:
 15539  			if wireType != 0 {
 15540  				return fmt.Errorf("proto: wrong wireType = %d for field UnhealthyTabletCount", wireType)
 15541  			}
 15542  			m.UnhealthyTabletCount = 0
 15543  			for shift := uint(0); ; shift += 7 {
 15544  				if shift >= 64 {
 15545  					return ErrIntOverflow
 15546  				}
 15547  				if iNdEx >= l {
 15548  					return io.ErrUnexpectedEOF
 15549  				}
 15550  				b := dAtA[iNdEx]
 15551  				iNdEx++
 15552  				m.UnhealthyTabletCount |= int32(b&0x7F) << shift
 15553  				if b < 0x80 {
 15554  					break
 15555  				}
 15556  			}
 15557  		case 3:
 15558  			if wireType != 0 {
 15559  				return fmt.Errorf("proto: wrong wireType = %d for field ReplicationLagSecondsMin", wireType)
 15560  			}
 15561  			m.ReplicationLagSecondsMin = 0
 15562  			for shift := uint(0); ; shift += 7 {
 15563  				if shift >= 64 {
 15564  					return ErrIntOverflow
 15565  				}
 15566  				if iNdEx >= l {
 15567  					return io.ErrUnexpectedEOF
 15568  				}
 15569  				b := dAtA[iNdEx]
 15570  				iNdEx++
 15571  				m.ReplicationLagSecondsMin |= uint32(b&0x7F) << shift
 15572  				if b < 0x80 {
 15573  					break
 15574  				}
 15575  			}
 15576  		case 4:
 15577  			if wireType != 0 {
 15578  				return fmt.Errorf("proto: wrong wireType = %d for field ReplicationLagSecondsMax", wireType)
 15579  			}
 15580  			m.ReplicationLagSecondsMax = 0
 15581  			for shift := uint(0); ; shift += 7 {
 15582  				if shift >= 64 {
 15583  					return ErrIntOverflow
 15584  				}
 15585  				if iNdEx >= l {
 15586  					return io.ErrUnexpectedEOF
 15587  				}
 15588  				b := dAtA[iNdEx]
 15589  				iNdEx++
 15590  				m.ReplicationLagSecondsMax |= uint32(b&0x7F) << shift
 15591  				if b < 0x80 {
 15592  					break
 15593  				}
 15594  			}
 15595  		default:
 15596  			iNdEx = preIndex
 15597  			skippy, err := skip(dAtA[iNdEx:])
 15598  			if err != nil {
 15599  				return err
 15600  			}
 15601  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15602  				return ErrInvalidLength
 15603  			}
 15604  			if (iNdEx + skippy) > l {
 15605  				return io.ErrUnexpectedEOF
 15606  			}
 15607  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15608  			iNdEx += skippy
 15609  		}
 15610  	}
 15611  
 15612  	if iNdEx > l {
 15613  		return io.ErrUnexpectedEOF
 15614  	}
 15615  	return nil
 15616  }
 15617  func (m *StreamHealthResponse) UnmarshalVT(dAtA []byte) error {
 15618  	l := len(dAtA)
 15619  	iNdEx := 0
 15620  	for iNdEx < l {
 15621  		preIndex := iNdEx
 15622  		var wire uint64
 15623  		for shift := uint(0); ; shift += 7 {
 15624  			if shift >= 64 {
 15625  				return ErrIntOverflow
 15626  			}
 15627  			if iNdEx >= l {
 15628  				return io.ErrUnexpectedEOF
 15629  			}
 15630  			b := dAtA[iNdEx]
 15631  			iNdEx++
 15632  			wire |= uint64(b&0x7F) << shift
 15633  			if b < 0x80 {
 15634  				break
 15635  			}
 15636  		}
 15637  		fieldNum := int32(wire >> 3)
 15638  		wireType := int(wire & 0x7)
 15639  		if wireType == 4 {
 15640  			return fmt.Errorf("proto: StreamHealthResponse: wiretype end group for non-group")
 15641  		}
 15642  		if fieldNum <= 0 {
 15643  			return fmt.Errorf("proto: StreamHealthResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15644  		}
 15645  		switch fieldNum {
 15646  		case 1:
 15647  			if wireType != 2 {
 15648  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 15649  			}
 15650  			var msglen int
 15651  			for shift := uint(0); ; shift += 7 {
 15652  				if shift >= 64 {
 15653  					return ErrIntOverflow
 15654  				}
 15655  				if iNdEx >= l {
 15656  					return io.ErrUnexpectedEOF
 15657  				}
 15658  				b := dAtA[iNdEx]
 15659  				iNdEx++
 15660  				msglen |= int(b&0x7F) << shift
 15661  				if b < 0x80 {
 15662  					break
 15663  				}
 15664  			}
 15665  			if msglen < 0 {
 15666  				return ErrInvalidLength
 15667  			}
 15668  			postIndex := iNdEx + msglen
 15669  			if postIndex < 0 {
 15670  				return ErrInvalidLength
 15671  			}
 15672  			if postIndex > l {
 15673  				return io.ErrUnexpectedEOF
 15674  			}
 15675  			if m.Target == nil {
 15676  				m.Target = &Target{}
 15677  			}
 15678  			if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15679  				return err
 15680  			}
 15681  			iNdEx = postIndex
 15682  		case 2:
 15683  			if wireType != 0 {
 15684  				return fmt.Errorf("proto: wrong wireType = %d for field Serving", wireType)
 15685  			}
 15686  			var v int
 15687  			for shift := uint(0); ; shift += 7 {
 15688  				if shift >= 64 {
 15689  					return ErrIntOverflow
 15690  				}
 15691  				if iNdEx >= l {
 15692  					return io.ErrUnexpectedEOF
 15693  				}
 15694  				b := dAtA[iNdEx]
 15695  				iNdEx++
 15696  				v |= int(b&0x7F) << shift
 15697  				if b < 0x80 {
 15698  					break
 15699  				}
 15700  			}
 15701  			m.Serving = bool(v != 0)
 15702  		case 3:
 15703  			if wireType != 0 {
 15704  				return fmt.Errorf("proto: wrong wireType = %d for field TabletExternallyReparentedTimestamp", wireType)
 15705  			}
 15706  			m.TabletExternallyReparentedTimestamp = 0
 15707  			for shift := uint(0); ; shift += 7 {
 15708  				if shift >= 64 {
 15709  					return ErrIntOverflow
 15710  				}
 15711  				if iNdEx >= l {
 15712  					return io.ErrUnexpectedEOF
 15713  				}
 15714  				b := dAtA[iNdEx]
 15715  				iNdEx++
 15716  				m.TabletExternallyReparentedTimestamp |= int64(b&0x7F) << shift
 15717  				if b < 0x80 {
 15718  					break
 15719  				}
 15720  			}
 15721  		case 4:
 15722  			if wireType != 2 {
 15723  				return fmt.Errorf("proto: wrong wireType = %d for field RealtimeStats", wireType)
 15724  			}
 15725  			var msglen int
 15726  			for shift := uint(0); ; shift += 7 {
 15727  				if shift >= 64 {
 15728  					return ErrIntOverflow
 15729  				}
 15730  				if iNdEx >= l {
 15731  					return io.ErrUnexpectedEOF
 15732  				}
 15733  				b := dAtA[iNdEx]
 15734  				iNdEx++
 15735  				msglen |= int(b&0x7F) << shift
 15736  				if b < 0x80 {
 15737  					break
 15738  				}
 15739  			}
 15740  			if msglen < 0 {
 15741  				return ErrInvalidLength
 15742  			}
 15743  			postIndex := iNdEx + msglen
 15744  			if postIndex < 0 {
 15745  				return ErrInvalidLength
 15746  			}
 15747  			if postIndex > l {
 15748  				return io.ErrUnexpectedEOF
 15749  			}
 15750  			if m.RealtimeStats == nil {
 15751  				m.RealtimeStats = &RealtimeStats{}
 15752  			}
 15753  			if err := m.RealtimeStats.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15754  				return err
 15755  			}
 15756  			iNdEx = postIndex
 15757  		case 5:
 15758  			if wireType != 2 {
 15759  				return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType)
 15760  			}
 15761  			var msglen int
 15762  			for shift := uint(0); ; shift += 7 {
 15763  				if shift >= 64 {
 15764  					return ErrIntOverflow
 15765  				}
 15766  				if iNdEx >= l {
 15767  					return io.ErrUnexpectedEOF
 15768  				}
 15769  				b := dAtA[iNdEx]
 15770  				iNdEx++
 15771  				msglen |= int(b&0x7F) << shift
 15772  				if b < 0x80 {
 15773  					break
 15774  				}
 15775  			}
 15776  			if msglen < 0 {
 15777  				return ErrInvalidLength
 15778  			}
 15779  			postIndex := iNdEx + msglen
 15780  			if postIndex < 0 {
 15781  				return ErrInvalidLength
 15782  			}
 15783  			if postIndex > l {
 15784  				return io.ErrUnexpectedEOF
 15785  			}
 15786  			if m.TabletAlias == nil {
 15787  				m.TabletAlias = &topodata.TabletAlias{}
 15788  			}
 15789  			if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15790  				return err
 15791  			}
 15792  			iNdEx = postIndex
 15793  		default:
 15794  			iNdEx = preIndex
 15795  			skippy, err := skip(dAtA[iNdEx:])
 15796  			if err != nil {
 15797  				return err
 15798  			}
 15799  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15800  				return ErrInvalidLength
 15801  			}
 15802  			if (iNdEx + skippy) > l {
 15803  				return io.ErrUnexpectedEOF
 15804  			}
 15805  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15806  			iNdEx += skippy
 15807  		}
 15808  	}
 15809  
 15810  	if iNdEx > l {
 15811  		return io.ErrUnexpectedEOF
 15812  	}
 15813  	return nil
 15814  }
 15815  func (m *TransactionMetadata) UnmarshalVT(dAtA []byte) error {
 15816  	l := len(dAtA)
 15817  	iNdEx := 0
 15818  	for iNdEx < l {
 15819  		preIndex := iNdEx
 15820  		var wire uint64
 15821  		for shift := uint(0); ; shift += 7 {
 15822  			if shift >= 64 {
 15823  				return ErrIntOverflow
 15824  			}
 15825  			if iNdEx >= l {
 15826  				return io.ErrUnexpectedEOF
 15827  			}
 15828  			b := dAtA[iNdEx]
 15829  			iNdEx++
 15830  			wire |= uint64(b&0x7F) << shift
 15831  			if b < 0x80 {
 15832  				break
 15833  			}
 15834  		}
 15835  		fieldNum := int32(wire >> 3)
 15836  		wireType := int(wire & 0x7)
 15837  		if wireType == 4 {
 15838  			return fmt.Errorf("proto: TransactionMetadata: wiretype end group for non-group")
 15839  		}
 15840  		if fieldNum <= 0 {
 15841  			return fmt.Errorf("proto: TransactionMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
 15842  		}
 15843  		switch fieldNum {
 15844  		case 1:
 15845  			if wireType != 2 {
 15846  				return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType)
 15847  			}
 15848  			var stringLen uint64
 15849  			for shift := uint(0); ; shift += 7 {
 15850  				if shift >= 64 {
 15851  					return ErrIntOverflow
 15852  				}
 15853  				if iNdEx >= l {
 15854  					return io.ErrUnexpectedEOF
 15855  				}
 15856  				b := dAtA[iNdEx]
 15857  				iNdEx++
 15858  				stringLen |= uint64(b&0x7F) << shift
 15859  				if b < 0x80 {
 15860  					break
 15861  				}
 15862  			}
 15863  			intStringLen := int(stringLen)
 15864  			if intStringLen < 0 {
 15865  				return ErrInvalidLength
 15866  			}
 15867  			postIndex := iNdEx + intStringLen
 15868  			if postIndex < 0 {
 15869  				return ErrInvalidLength
 15870  			}
 15871  			if postIndex > l {
 15872  				return io.ErrUnexpectedEOF
 15873  			}
 15874  			m.Dtid = string(dAtA[iNdEx:postIndex])
 15875  			iNdEx = postIndex
 15876  		case 2:
 15877  			if wireType != 0 {
 15878  				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
 15879  			}
 15880  			m.State = 0
 15881  			for shift := uint(0); ; shift += 7 {
 15882  				if shift >= 64 {
 15883  					return ErrIntOverflow
 15884  				}
 15885  				if iNdEx >= l {
 15886  					return io.ErrUnexpectedEOF
 15887  				}
 15888  				b := dAtA[iNdEx]
 15889  				iNdEx++
 15890  				m.State |= TransactionState(b&0x7F) << shift
 15891  				if b < 0x80 {
 15892  					break
 15893  				}
 15894  			}
 15895  		case 3:
 15896  			if wireType != 0 {
 15897  				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType)
 15898  			}
 15899  			m.TimeCreated = 0
 15900  			for shift := uint(0); ; shift += 7 {
 15901  				if shift >= 64 {
 15902  					return ErrIntOverflow
 15903  				}
 15904  				if iNdEx >= l {
 15905  					return io.ErrUnexpectedEOF
 15906  				}
 15907  				b := dAtA[iNdEx]
 15908  				iNdEx++
 15909  				m.TimeCreated |= int64(b&0x7F) << shift
 15910  				if b < 0x80 {
 15911  					break
 15912  				}
 15913  			}
 15914  		case 4:
 15915  			if wireType != 2 {
 15916  				return fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType)
 15917  			}
 15918  			var msglen int
 15919  			for shift := uint(0); ; shift += 7 {
 15920  				if shift >= 64 {
 15921  					return ErrIntOverflow
 15922  				}
 15923  				if iNdEx >= l {
 15924  					return io.ErrUnexpectedEOF
 15925  				}
 15926  				b := dAtA[iNdEx]
 15927  				iNdEx++
 15928  				msglen |= int(b&0x7F) << shift
 15929  				if b < 0x80 {
 15930  					break
 15931  				}
 15932  			}
 15933  			if msglen < 0 {
 15934  				return ErrInvalidLength
 15935  			}
 15936  			postIndex := iNdEx + msglen
 15937  			if postIndex < 0 {
 15938  				return ErrInvalidLength
 15939  			}
 15940  			if postIndex > l {
 15941  				return io.ErrUnexpectedEOF
 15942  			}
 15943  			m.Participants = append(m.Participants, &Target{})
 15944  			if err := m.Participants[len(m.Participants)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15945  				return err
 15946  			}
 15947  			iNdEx = postIndex
 15948  		default:
 15949  			iNdEx = preIndex
 15950  			skippy, err := skip(dAtA[iNdEx:])
 15951  			if err != nil {
 15952  				return err
 15953  			}
 15954  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15955  				return ErrInvalidLength
 15956  			}
 15957  			if (iNdEx + skippy) > l {
 15958  				return io.ErrUnexpectedEOF
 15959  			}
 15960  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15961  			iNdEx += skippy
 15962  		}
 15963  	}
 15964  
 15965  	if iNdEx > l {
 15966  		return io.ErrUnexpectedEOF
 15967  	}
 15968  	return nil
 15969  }
 15970  func skip(dAtA []byte) (n int, err error) {
 15971  	l := len(dAtA)
 15972  	iNdEx := 0
 15973  	depth := 0
 15974  	for iNdEx < l {
 15975  		var wire uint64
 15976  		for shift := uint(0); ; shift += 7 {
 15977  			if shift >= 64 {
 15978  				return 0, ErrIntOverflow
 15979  			}
 15980  			if iNdEx >= l {
 15981  				return 0, io.ErrUnexpectedEOF
 15982  			}
 15983  			b := dAtA[iNdEx]
 15984  			iNdEx++
 15985  			wire |= (uint64(b) & 0x7F) << shift
 15986  			if b < 0x80 {
 15987  				break
 15988  			}
 15989  		}
 15990  		wireType := int(wire & 0x7)
 15991  		switch wireType {
 15992  		case 0:
 15993  			for shift := uint(0); ; shift += 7 {
 15994  				if shift >= 64 {
 15995  					return 0, ErrIntOverflow
 15996  				}
 15997  				if iNdEx >= l {
 15998  					return 0, io.ErrUnexpectedEOF
 15999  				}
 16000  				iNdEx++
 16001  				if dAtA[iNdEx-1] < 0x80 {
 16002  					break
 16003  				}
 16004  			}
 16005  		case 1:
 16006  			iNdEx += 8
 16007  		case 2:
 16008  			var length int
 16009  			for shift := uint(0); ; shift += 7 {
 16010  				if shift >= 64 {
 16011  					return 0, ErrIntOverflow
 16012  				}
 16013  				if iNdEx >= l {
 16014  					return 0, io.ErrUnexpectedEOF
 16015  				}
 16016  				b := dAtA[iNdEx]
 16017  				iNdEx++
 16018  				length |= (int(b) & 0x7F) << shift
 16019  				if b < 0x80 {
 16020  					break
 16021  				}
 16022  			}
 16023  			if length < 0 {
 16024  				return 0, ErrInvalidLength
 16025  			}
 16026  			iNdEx += length
 16027  		case 3:
 16028  			depth++
 16029  		case 4:
 16030  			if depth == 0 {
 16031  				return 0, ErrUnexpectedEndOfGroup
 16032  			}
 16033  			depth--
 16034  		case 5:
 16035  			iNdEx += 4
 16036  		default:
 16037  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 16038  		}
 16039  		if iNdEx < 0 {
 16040  			return 0, ErrInvalidLength
 16041  		}
 16042  		if depth == 0 {
 16043  			return iNdEx, nil
 16044  		}
 16045  	}
 16046  	return 0, io.ErrUnexpectedEOF
 16047  }
 16048  
 16049  var (
 16050  	ErrInvalidLength        = fmt.Errorf("proto: negative length found during unmarshaling")
 16051  	ErrIntOverflow          = fmt.Errorf("proto: integer overflow")
 16052  	ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group")
 16053  )