vitess.io/vitess@v0.16.2/go/vt/proto/vtadmin/vtadmin_vtproto.pb.go (about)

     1  // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
     2  // protoc-gen-go-vtproto version: v0.4.0
     3  // source: vtadmin.proto
     4  
     5  package vtadmin
     6  
     7  import (
     8  	fmt "fmt"
     9  	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
    10  	io "io"
    11  	bits "math/bits"
    12  	logutil "vitess.io/vitess/go/vt/proto/logutil"
    13  	mysqlctl "vitess.io/vitess/go/vt/proto/mysqlctl"
    14  	tabletmanagerdata "vitess.io/vitess/go/vt/proto/tabletmanagerdata"
    15  	topodata "vitess.io/vitess/go/vt/proto/topodata"
    16  	vschema "vitess.io/vitess/go/vt/proto/vschema"
    17  	vtctldata "vitess.io/vitess/go/vt/proto/vtctldata"
    18  )
    19  
    20  const (
    21  	// Verify that this generated code is sufficiently up-to-date.
    22  	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
    23  	// Verify that runtime/protoimpl is sufficiently up-to-date.
    24  	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
    25  )
    26  
    27  func (m *Cluster) MarshalVT() (dAtA []byte, err error) {
    28  	if m == nil {
    29  		return nil, nil
    30  	}
    31  	size := m.SizeVT()
    32  	dAtA = make([]byte, size)
    33  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
    34  	if err != nil {
    35  		return nil, err
    36  	}
    37  	return dAtA[:n], nil
    38  }
    39  
    40  func (m *Cluster) MarshalToVT(dAtA []byte) (int, error) {
    41  	size := m.SizeVT()
    42  	return m.MarshalToSizedBufferVT(dAtA[:size])
    43  }
    44  
    45  func (m *Cluster) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
    46  	if m == nil {
    47  		return 0, nil
    48  	}
    49  	i := len(dAtA)
    50  	_ = i
    51  	var l int
    52  	_ = l
    53  	if m.unknownFields != nil {
    54  		i -= len(m.unknownFields)
    55  		copy(dAtA[i:], m.unknownFields)
    56  	}
    57  	if len(m.Name) > 0 {
    58  		i -= len(m.Name)
    59  		copy(dAtA[i:], m.Name)
    60  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
    61  		i--
    62  		dAtA[i] = 0x12
    63  	}
    64  	if len(m.Id) > 0 {
    65  		i -= len(m.Id)
    66  		copy(dAtA[i:], m.Id)
    67  		i = encodeVarint(dAtA, i, uint64(len(m.Id)))
    68  		i--
    69  		dAtA[i] = 0xa
    70  	}
    71  	return len(dAtA) - i, nil
    72  }
    73  
    74  func (m *ClusterBackup) MarshalVT() (dAtA []byte, err error) {
    75  	if m == nil {
    76  		return nil, nil
    77  	}
    78  	size := m.SizeVT()
    79  	dAtA = make([]byte, size)
    80  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  	return dAtA[:n], nil
    85  }
    86  
    87  func (m *ClusterBackup) MarshalToVT(dAtA []byte) (int, error) {
    88  	size := m.SizeVT()
    89  	return m.MarshalToSizedBufferVT(dAtA[:size])
    90  }
    91  
    92  func (m *ClusterBackup) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
    93  	if m == nil {
    94  		return 0, nil
    95  	}
    96  	i := len(dAtA)
    97  	_ = i
    98  	var l int
    99  	_ = l
   100  	if m.unknownFields != nil {
   101  		i -= len(m.unknownFields)
   102  		copy(dAtA[i:], m.unknownFields)
   103  	}
   104  	if m.Backup != nil {
   105  		size, err := m.Backup.MarshalToSizedBufferVT(dAtA[:i])
   106  		if err != nil {
   107  			return 0, err
   108  		}
   109  		i -= size
   110  		i = encodeVarint(dAtA, i, uint64(size))
   111  		i--
   112  		dAtA[i] = 0x12
   113  	}
   114  	if m.Cluster != nil {
   115  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   116  		if err != nil {
   117  			return 0, err
   118  		}
   119  		i -= size
   120  		i = encodeVarint(dAtA, i, uint64(size))
   121  		i--
   122  		dAtA[i] = 0xa
   123  	}
   124  	return len(dAtA) - i, nil
   125  }
   126  
   127  func (m *ClusterCellsAliases) MarshalVT() (dAtA []byte, err error) {
   128  	if m == nil {
   129  		return nil, nil
   130  	}
   131  	size := m.SizeVT()
   132  	dAtA = make([]byte, size)
   133  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   134  	if err != nil {
   135  		return nil, err
   136  	}
   137  	return dAtA[:n], nil
   138  }
   139  
   140  func (m *ClusterCellsAliases) MarshalToVT(dAtA []byte) (int, error) {
   141  	size := m.SizeVT()
   142  	return m.MarshalToSizedBufferVT(dAtA[:size])
   143  }
   144  
   145  func (m *ClusterCellsAliases) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   146  	if m == nil {
   147  		return 0, nil
   148  	}
   149  	i := len(dAtA)
   150  	_ = i
   151  	var l int
   152  	_ = l
   153  	if m.unknownFields != nil {
   154  		i -= len(m.unknownFields)
   155  		copy(dAtA[i:], m.unknownFields)
   156  	}
   157  	if len(m.Aliases) > 0 {
   158  		for k := range m.Aliases {
   159  			v := m.Aliases[k]
   160  			baseI := i
   161  			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
   162  			if err != nil {
   163  				return 0, err
   164  			}
   165  			i -= size
   166  			i = encodeVarint(dAtA, i, uint64(size))
   167  			i--
   168  			dAtA[i] = 0x12
   169  			i -= len(k)
   170  			copy(dAtA[i:], k)
   171  			i = encodeVarint(dAtA, i, uint64(len(k)))
   172  			i--
   173  			dAtA[i] = 0xa
   174  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   175  			i--
   176  			dAtA[i] = 0x12
   177  		}
   178  	}
   179  	if m.Cluster != nil {
   180  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   181  		if err != nil {
   182  			return 0, err
   183  		}
   184  		i -= size
   185  		i = encodeVarint(dAtA, i, uint64(size))
   186  		i--
   187  		dAtA[i] = 0xa
   188  	}
   189  	return len(dAtA) - i, nil
   190  }
   191  
   192  func (m *ClusterCellInfo) MarshalVT() (dAtA []byte, err error) {
   193  	if m == nil {
   194  		return nil, nil
   195  	}
   196  	size := m.SizeVT()
   197  	dAtA = make([]byte, size)
   198  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   199  	if err != nil {
   200  		return nil, err
   201  	}
   202  	return dAtA[:n], nil
   203  }
   204  
   205  func (m *ClusterCellInfo) MarshalToVT(dAtA []byte) (int, error) {
   206  	size := m.SizeVT()
   207  	return m.MarshalToSizedBufferVT(dAtA[:size])
   208  }
   209  
   210  func (m *ClusterCellInfo) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   211  	if m == nil {
   212  		return 0, nil
   213  	}
   214  	i := len(dAtA)
   215  	_ = i
   216  	var l int
   217  	_ = l
   218  	if m.unknownFields != nil {
   219  		i -= len(m.unknownFields)
   220  		copy(dAtA[i:], m.unknownFields)
   221  	}
   222  	if m.CellInfo != nil {
   223  		size, err := m.CellInfo.MarshalToSizedBufferVT(dAtA[:i])
   224  		if err != nil {
   225  			return 0, err
   226  		}
   227  		i -= size
   228  		i = encodeVarint(dAtA, i, uint64(size))
   229  		i--
   230  		dAtA[i] = 0x1a
   231  	}
   232  	if len(m.Name) > 0 {
   233  		i -= len(m.Name)
   234  		copy(dAtA[i:], m.Name)
   235  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
   236  		i--
   237  		dAtA[i] = 0x12
   238  	}
   239  	if m.Cluster != nil {
   240  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   241  		if err != nil {
   242  			return 0, err
   243  		}
   244  		i -= size
   245  		i = encodeVarint(dAtA, i, uint64(size))
   246  		i--
   247  		dAtA[i] = 0xa
   248  	}
   249  	return len(dAtA) - i, nil
   250  }
   251  
   252  func (m *ClusterShardReplicationPosition) MarshalVT() (dAtA []byte, err error) {
   253  	if m == nil {
   254  		return nil, nil
   255  	}
   256  	size := m.SizeVT()
   257  	dAtA = make([]byte, size)
   258  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   259  	if err != nil {
   260  		return nil, err
   261  	}
   262  	return dAtA[:n], nil
   263  }
   264  
   265  func (m *ClusterShardReplicationPosition) MarshalToVT(dAtA []byte) (int, error) {
   266  	size := m.SizeVT()
   267  	return m.MarshalToSizedBufferVT(dAtA[:size])
   268  }
   269  
   270  func (m *ClusterShardReplicationPosition) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   271  	if m == nil {
   272  		return 0, nil
   273  	}
   274  	i := len(dAtA)
   275  	_ = i
   276  	var l int
   277  	_ = l
   278  	if m.unknownFields != nil {
   279  		i -= len(m.unknownFields)
   280  		copy(dAtA[i:], m.unknownFields)
   281  	}
   282  	if m.PositionInfo != nil {
   283  		size, err := m.PositionInfo.MarshalToSizedBufferVT(dAtA[:i])
   284  		if err != nil {
   285  			return 0, err
   286  		}
   287  		i -= size
   288  		i = encodeVarint(dAtA, i, uint64(size))
   289  		i--
   290  		dAtA[i] = 0x22
   291  	}
   292  	if len(m.Shard) > 0 {
   293  		i -= len(m.Shard)
   294  		copy(dAtA[i:], m.Shard)
   295  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
   296  		i--
   297  		dAtA[i] = 0x1a
   298  	}
   299  	if len(m.Keyspace) > 0 {
   300  		i -= len(m.Keyspace)
   301  		copy(dAtA[i:], m.Keyspace)
   302  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
   303  		i--
   304  		dAtA[i] = 0x12
   305  	}
   306  	if m.Cluster != nil {
   307  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   308  		if err != nil {
   309  			return 0, err
   310  		}
   311  		i -= size
   312  		i = encodeVarint(dAtA, i, uint64(size))
   313  		i--
   314  		dAtA[i] = 0xa
   315  	}
   316  	return len(dAtA) - i, nil
   317  }
   318  
   319  func (m *ClusterWorkflows) MarshalVT() (dAtA []byte, err error) {
   320  	if m == nil {
   321  		return nil, nil
   322  	}
   323  	size := m.SizeVT()
   324  	dAtA = make([]byte, size)
   325  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   326  	if err != nil {
   327  		return nil, err
   328  	}
   329  	return dAtA[:n], nil
   330  }
   331  
   332  func (m *ClusterWorkflows) MarshalToVT(dAtA []byte) (int, error) {
   333  	size := m.SizeVT()
   334  	return m.MarshalToSizedBufferVT(dAtA[:size])
   335  }
   336  
   337  func (m *ClusterWorkflows) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   338  	if m == nil {
   339  		return 0, nil
   340  	}
   341  	i := len(dAtA)
   342  	_ = i
   343  	var l int
   344  	_ = l
   345  	if m.unknownFields != nil {
   346  		i -= len(m.unknownFields)
   347  		copy(dAtA[i:], m.unknownFields)
   348  	}
   349  	if len(m.Warnings) > 0 {
   350  		for iNdEx := len(m.Warnings) - 1; iNdEx >= 0; iNdEx-- {
   351  			i -= len(m.Warnings[iNdEx])
   352  			copy(dAtA[i:], m.Warnings[iNdEx])
   353  			i = encodeVarint(dAtA, i, uint64(len(m.Warnings[iNdEx])))
   354  			i--
   355  			dAtA[i] = 0x12
   356  		}
   357  	}
   358  	if len(m.Workflows) > 0 {
   359  		for iNdEx := len(m.Workflows) - 1; iNdEx >= 0; iNdEx-- {
   360  			size, err := m.Workflows[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   361  			if err != nil {
   362  				return 0, err
   363  			}
   364  			i -= size
   365  			i = encodeVarint(dAtA, i, uint64(size))
   366  			i--
   367  			dAtA[i] = 0xa
   368  		}
   369  	}
   370  	return len(dAtA) - i, nil
   371  }
   372  
   373  func (m *Keyspace) MarshalVT() (dAtA []byte, err error) {
   374  	if m == nil {
   375  		return nil, nil
   376  	}
   377  	size := m.SizeVT()
   378  	dAtA = make([]byte, size)
   379  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   380  	if err != nil {
   381  		return nil, err
   382  	}
   383  	return dAtA[:n], nil
   384  }
   385  
   386  func (m *Keyspace) MarshalToVT(dAtA []byte) (int, error) {
   387  	size := m.SizeVT()
   388  	return m.MarshalToSizedBufferVT(dAtA[:size])
   389  }
   390  
   391  func (m *Keyspace) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   392  	if m == nil {
   393  		return 0, nil
   394  	}
   395  	i := len(dAtA)
   396  	_ = i
   397  	var l int
   398  	_ = l
   399  	if m.unknownFields != nil {
   400  		i -= len(m.unknownFields)
   401  		copy(dAtA[i:], m.unknownFields)
   402  	}
   403  	if len(m.Shards) > 0 {
   404  		for k := range m.Shards {
   405  			v := m.Shards[k]
   406  			baseI := i
   407  			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
   408  			if err != nil {
   409  				return 0, err
   410  			}
   411  			i -= size
   412  			i = encodeVarint(dAtA, i, uint64(size))
   413  			i--
   414  			dAtA[i] = 0x12
   415  			i -= len(k)
   416  			copy(dAtA[i:], k)
   417  			i = encodeVarint(dAtA, i, uint64(len(k)))
   418  			i--
   419  			dAtA[i] = 0xa
   420  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   421  			i--
   422  			dAtA[i] = 0x1a
   423  		}
   424  	}
   425  	if m.Keyspace != nil {
   426  		size, err := m.Keyspace.MarshalToSizedBufferVT(dAtA[:i])
   427  		if err != nil {
   428  			return 0, err
   429  		}
   430  		i -= size
   431  		i = encodeVarint(dAtA, i, uint64(size))
   432  		i--
   433  		dAtA[i] = 0x12
   434  	}
   435  	if m.Cluster != nil {
   436  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   437  		if err != nil {
   438  			return 0, err
   439  		}
   440  		i -= size
   441  		i = encodeVarint(dAtA, i, uint64(size))
   442  		i--
   443  		dAtA[i] = 0xa
   444  	}
   445  	return len(dAtA) - i, nil
   446  }
   447  
   448  func (m *Schema_ShardTableSize) MarshalVT() (dAtA []byte, err error) {
   449  	if m == nil {
   450  		return nil, nil
   451  	}
   452  	size := m.SizeVT()
   453  	dAtA = make([]byte, size)
   454  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   455  	if err != nil {
   456  		return nil, err
   457  	}
   458  	return dAtA[:n], nil
   459  }
   460  
   461  func (m *Schema_ShardTableSize) MarshalToVT(dAtA []byte) (int, error) {
   462  	size := m.SizeVT()
   463  	return m.MarshalToSizedBufferVT(dAtA[:size])
   464  }
   465  
   466  func (m *Schema_ShardTableSize) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   467  	if m == nil {
   468  		return 0, nil
   469  	}
   470  	i := len(dAtA)
   471  	_ = i
   472  	var l int
   473  	_ = l
   474  	if m.unknownFields != nil {
   475  		i -= len(m.unknownFields)
   476  		copy(dAtA[i:], m.unknownFields)
   477  	}
   478  	if m.DataLength != 0 {
   479  		i = encodeVarint(dAtA, i, uint64(m.DataLength))
   480  		i--
   481  		dAtA[i] = 0x10
   482  	}
   483  	if m.RowCount != 0 {
   484  		i = encodeVarint(dAtA, i, uint64(m.RowCount))
   485  		i--
   486  		dAtA[i] = 0x8
   487  	}
   488  	return len(dAtA) - i, nil
   489  }
   490  
   491  func (m *Schema_TableSize) MarshalVT() (dAtA []byte, err error) {
   492  	if m == nil {
   493  		return nil, nil
   494  	}
   495  	size := m.SizeVT()
   496  	dAtA = make([]byte, size)
   497  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   498  	if err != nil {
   499  		return nil, err
   500  	}
   501  	return dAtA[:n], nil
   502  }
   503  
   504  func (m *Schema_TableSize) MarshalToVT(dAtA []byte) (int, error) {
   505  	size := m.SizeVT()
   506  	return m.MarshalToSizedBufferVT(dAtA[:size])
   507  }
   508  
   509  func (m *Schema_TableSize) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   510  	if m == nil {
   511  		return 0, nil
   512  	}
   513  	i := len(dAtA)
   514  	_ = i
   515  	var l int
   516  	_ = l
   517  	if m.unknownFields != nil {
   518  		i -= len(m.unknownFields)
   519  		copy(dAtA[i:], m.unknownFields)
   520  	}
   521  	if len(m.ByShard) > 0 {
   522  		for k := range m.ByShard {
   523  			v := m.ByShard[k]
   524  			baseI := i
   525  			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
   526  			if err != nil {
   527  				return 0, err
   528  			}
   529  			i -= size
   530  			i = encodeVarint(dAtA, i, uint64(size))
   531  			i--
   532  			dAtA[i] = 0x12
   533  			i -= len(k)
   534  			copy(dAtA[i:], k)
   535  			i = encodeVarint(dAtA, i, uint64(len(k)))
   536  			i--
   537  			dAtA[i] = 0xa
   538  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   539  			i--
   540  			dAtA[i] = 0x1a
   541  		}
   542  	}
   543  	if m.DataLength != 0 {
   544  		i = encodeVarint(dAtA, i, uint64(m.DataLength))
   545  		i--
   546  		dAtA[i] = 0x10
   547  	}
   548  	if m.RowCount != 0 {
   549  		i = encodeVarint(dAtA, i, uint64(m.RowCount))
   550  		i--
   551  		dAtA[i] = 0x8
   552  	}
   553  	return len(dAtA) - i, nil
   554  }
   555  
   556  func (m *Schema) MarshalVT() (dAtA []byte, err error) {
   557  	if m == nil {
   558  		return nil, nil
   559  	}
   560  	size := m.SizeVT()
   561  	dAtA = make([]byte, size)
   562  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   563  	if err != nil {
   564  		return nil, err
   565  	}
   566  	return dAtA[:n], nil
   567  }
   568  
   569  func (m *Schema) MarshalToVT(dAtA []byte) (int, error) {
   570  	size := m.SizeVT()
   571  	return m.MarshalToSizedBufferVT(dAtA[:size])
   572  }
   573  
   574  func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   575  	if m == nil {
   576  		return 0, nil
   577  	}
   578  	i := len(dAtA)
   579  	_ = i
   580  	var l int
   581  	_ = l
   582  	if m.unknownFields != nil {
   583  		i -= len(m.unknownFields)
   584  		copy(dAtA[i:], m.unknownFields)
   585  	}
   586  	if len(m.TableSizes) > 0 {
   587  		for k := range m.TableSizes {
   588  			v := m.TableSizes[k]
   589  			baseI := i
   590  			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
   591  			if err != nil {
   592  				return 0, err
   593  			}
   594  			i -= size
   595  			i = encodeVarint(dAtA, i, uint64(size))
   596  			i--
   597  			dAtA[i] = 0x12
   598  			i -= len(k)
   599  			copy(dAtA[i:], k)
   600  			i = encodeVarint(dAtA, i, uint64(len(k)))
   601  			i--
   602  			dAtA[i] = 0xa
   603  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   604  			i--
   605  			dAtA[i] = 0x22
   606  		}
   607  	}
   608  	if len(m.TableDefinitions) > 0 {
   609  		for iNdEx := len(m.TableDefinitions) - 1; iNdEx >= 0; iNdEx-- {
   610  			size, err := m.TableDefinitions[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   611  			if err != nil {
   612  				return 0, err
   613  			}
   614  			i -= size
   615  			i = encodeVarint(dAtA, i, uint64(size))
   616  			i--
   617  			dAtA[i] = 0x1a
   618  		}
   619  	}
   620  	if len(m.Keyspace) > 0 {
   621  		i -= len(m.Keyspace)
   622  		copy(dAtA[i:], m.Keyspace)
   623  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
   624  		i--
   625  		dAtA[i] = 0x12
   626  	}
   627  	if m.Cluster != nil {
   628  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   629  		if err != nil {
   630  			return 0, err
   631  		}
   632  		i -= size
   633  		i = encodeVarint(dAtA, i, uint64(size))
   634  		i--
   635  		dAtA[i] = 0xa
   636  	}
   637  	return len(dAtA) - i, nil
   638  }
   639  
   640  func (m *Shard) MarshalVT() (dAtA []byte, err error) {
   641  	if m == nil {
   642  		return nil, nil
   643  	}
   644  	size := m.SizeVT()
   645  	dAtA = make([]byte, size)
   646  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   647  	if err != nil {
   648  		return nil, err
   649  	}
   650  	return dAtA[:n], nil
   651  }
   652  
   653  func (m *Shard) MarshalToVT(dAtA []byte) (int, error) {
   654  	size := m.SizeVT()
   655  	return m.MarshalToSizedBufferVT(dAtA[:size])
   656  }
   657  
   658  func (m *Shard) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   659  	if m == nil {
   660  		return 0, nil
   661  	}
   662  	i := len(dAtA)
   663  	_ = i
   664  	var l int
   665  	_ = l
   666  	if m.unknownFields != nil {
   667  		i -= len(m.unknownFields)
   668  		copy(dAtA[i:], m.unknownFields)
   669  	}
   670  	if m.Shard != nil {
   671  		size, err := m.Shard.MarshalToSizedBufferVT(dAtA[:i])
   672  		if err != nil {
   673  			return 0, err
   674  		}
   675  		i -= size
   676  		i = encodeVarint(dAtA, i, uint64(size))
   677  		i--
   678  		dAtA[i] = 0x12
   679  	}
   680  	if m.Cluster != nil {
   681  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   682  		if err != nil {
   683  			return 0, err
   684  		}
   685  		i -= size
   686  		i = encodeVarint(dAtA, i, uint64(size))
   687  		i--
   688  		dAtA[i] = 0xa
   689  	}
   690  	return len(dAtA) - i, nil
   691  }
   692  
   693  func (m *SrvVSchema) MarshalVT() (dAtA []byte, err error) {
   694  	if m == nil {
   695  		return nil, nil
   696  	}
   697  	size := m.SizeVT()
   698  	dAtA = make([]byte, size)
   699  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   700  	if err != nil {
   701  		return nil, err
   702  	}
   703  	return dAtA[:n], nil
   704  }
   705  
   706  func (m *SrvVSchema) MarshalToVT(dAtA []byte) (int, error) {
   707  	size := m.SizeVT()
   708  	return m.MarshalToSizedBufferVT(dAtA[:size])
   709  }
   710  
   711  func (m *SrvVSchema) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   712  	if m == nil {
   713  		return 0, nil
   714  	}
   715  	i := len(dAtA)
   716  	_ = i
   717  	var l int
   718  	_ = l
   719  	if m.unknownFields != nil {
   720  		i -= len(m.unknownFields)
   721  		copy(dAtA[i:], m.unknownFields)
   722  	}
   723  	if m.SrvVSchema != nil {
   724  		size, err := m.SrvVSchema.MarshalToSizedBufferVT(dAtA[:i])
   725  		if err != nil {
   726  			return 0, err
   727  		}
   728  		i -= size
   729  		i = encodeVarint(dAtA, i, uint64(size))
   730  		i--
   731  		dAtA[i] = 0x1a
   732  	}
   733  	if m.Cluster != nil {
   734  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   735  		if err != nil {
   736  			return 0, err
   737  		}
   738  		i -= size
   739  		i = encodeVarint(dAtA, i, uint64(size))
   740  		i--
   741  		dAtA[i] = 0x12
   742  	}
   743  	if len(m.Cell) > 0 {
   744  		i -= len(m.Cell)
   745  		copy(dAtA[i:], m.Cell)
   746  		i = encodeVarint(dAtA, i, uint64(len(m.Cell)))
   747  		i--
   748  		dAtA[i] = 0xa
   749  	}
   750  	return len(dAtA) - i, nil
   751  }
   752  
   753  func (m *Tablet) MarshalVT() (dAtA []byte, err error) {
   754  	if m == nil {
   755  		return nil, nil
   756  	}
   757  	size := m.SizeVT()
   758  	dAtA = make([]byte, size)
   759  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   760  	if err != nil {
   761  		return nil, err
   762  	}
   763  	return dAtA[:n], nil
   764  }
   765  
   766  func (m *Tablet) MarshalToVT(dAtA []byte) (int, error) {
   767  	size := m.SizeVT()
   768  	return m.MarshalToSizedBufferVT(dAtA[:size])
   769  }
   770  
   771  func (m *Tablet) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   772  	if m == nil {
   773  		return 0, nil
   774  	}
   775  	i := len(dAtA)
   776  	_ = i
   777  	var l int
   778  	_ = l
   779  	if m.unknownFields != nil {
   780  		i -= len(m.unknownFields)
   781  		copy(dAtA[i:], m.unknownFields)
   782  	}
   783  	if len(m.FQDN) > 0 {
   784  		i -= len(m.FQDN)
   785  		copy(dAtA[i:], m.FQDN)
   786  		i = encodeVarint(dAtA, i, uint64(len(m.FQDN)))
   787  		i--
   788  		dAtA[i] = 0x22
   789  	}
   790  	if m.State != 0 {
   791  		i = encodeVarint(dAtA, i, uint64(m.State))
   792  		i--
   793  		dAtA[i] = 0x18
   794  	}
   795  	if m.Tablet != nil {
   796  		size, err := m.Tablet.MarshalToSizedBufferVT(dAtA[:i])
   797  		if err != nil {
   798  			return 0, err
   799  		}
   800  		i -= size
   801  		i = encodeVarint(dAtA, i, uint64(size))
   802  		i--
   803  		dAtA[i] = 0x12
   804  	}
   805  	if m.Cluster != nil {
   806  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   807  		if err != nil {
   808  			return 0, err
   809  		}
   810  		i -= size
   811  		i = encodeVarint(dAtA, i, uint64(size))
   812  		i--
   813  		dAtA[i] = 0xa
   814  	}
   815  	return len(dAtA) - i, nil
   816  }
   817  
   818  func (m *VSchema) MarshalVT() (dAtA []byte, err error) {
   819  	if m == nil {
   820  		return nil, nil
   821  	}
   822  	size := m.SizeVT()
   823  	dAtA = make([]byte, size)
   824  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   825  	if err != nil {
   826  		return nil, err
   827  	}
   828  	return dAtA[:n], nil
   829  }
   830  
   831  func (m *VSchema) MarshalToVT(dAtA []byte) (int, error) {
   832  	size := m.SizeVT()
   833  	return m.MarshalToSizedBufferVT(dAtA[:size])
   834  }
   835  
   836  func (m *VSchema) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   837  	if m == nil {
   838  		return 0, nil
   839  	}
   840  	i := len(dAtA)
   841  	_ = i
   842  	var l int
   843  	_ = l
   844  	if m.unknownFields != nil {
   845  		i -= len(m.unknownFields)
   846  		copy(dAtA[i:], m.unknownFields)
   847  	}
   848  	if m.VSchema != nil {
   849  		size, err := m.VSchema.MarshalToSizedBufferVT(dAtA[:i])
   850  		if err != nil {
   851  			return 0, err
   852  		}
   853  		i -= size
   854  		i = encodeVarint(dAtA, i, uint64(size))
   855  		i--
   856  		dAtA[i] = 0x1a
   857  	}
   858  	if len(m.Name) > 0 {
   859  		i -= len(m.Name)
   860  		copy(dAtA[i:], m.Name)
   861  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
   862  		i--
   863  		dAtA[i] = 0x12
   864  	}
   865  	if m.Cluster != nil {
   866  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   867  		if err != nil {
   868  			return 0, err
   869  		}
   870  		i -= size
   871  		i = encodeVarint(dAtA, i, uint64(size))
   872  		i--
   873  		dAtA[i] = 0xa
   874  	}
   875  	return len(dAtA) - i, nil
   876  }
   877  
   878  func (m *Vtctld) MarshalVT() (dAtA []byte, err error) {
   879  	if m == nil {
   880  		return nil, nil
   881  	}
   882  	size := m.SizeVT()
   883  	dAtA = make([]byte, size)
   884  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   885  	if err != nil {
   886  		return nil, err
   887  	}
   888  	return dAtA[:n], nil
   889  }
   890  
   891  func (m *Vtctld) MarshalToVT(dAtA []byte) (int, error) {
   892  	size := m.SizeVT()
   893  	return m.MarshalToSizedBufferVT(dAtA[:size])
   894  }
   895  
   896  func (m *Vtctld) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   897  	if m == nil {
   898  		return 0, nil
   899  	}
   900  	i := len(dAtA)
   901  	_ = i
   902  	var l int
   903  	_ = l
   904  	if m.unknownFields != nil {
   905  		i -= len(m.unknownFields)
   906  		copy(dAtA[i:], m.unknownFields)
   907  	}
   908  	if len(m.FQDN) > 0 {
   909  		i -= len(m.FQDN)
   910  		copy(dAtA[i:], m.FQDN)
   911  		i = encodeVarint(dAtA, i, uint64(len(m.FQDN)))
   912  		i--
   913  		dAtA[i] = 0x1a
   914  	}
   915  	if m.Cluster != nil {
   916  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   917  		if err != nil {
   918  			return 0, err
   919  		}
   920  		i -= size
   921  		i = encodeVarint(dAtA, i, uint64(size))
   922  		i--
   923  		dAtA[i] = 0x12
   924  	}
   925  	if len(m.Hostname) > 0 {
   926  		i -= len(m.Hostname)
   927  		copy(dAtA[i:], m.Hostname)
   928  		i = encodeVarint(dAtA, i, uint64(len(m.Hostname)))
   929  		i--
   930  		dAtA[i] = 0xa
   931  	}
   932  	return len(dAtA) - i, nil
   933  }
   934  
   935  func (m *VTGate) 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 *VTGate) MarshalToVT(dAtA []byte) (int, error) {
   949  	size := m.SizeVT()
   950  	return m.MarshalToSizedBufferVT(dAtA[:size])
   951  }
   952  
   953  func (m *VTGate) 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 len(m.FQDN) > 0 {
   966  		i -= len(m.FQDN)
   967  		copy(dAtA[i:], m.FQDN)
   968  		i = encodeVarint(dAtA, i, uint64(len(m.FQDN)))
   969  		i--
   970  		dAtA[i] = 0x32
   971  	}
   972  	if len(m.Keyspaces) > 0 {
   973  		for iNdEx := len(m.Keyspaces) - 1; iNdEx >= 0; iNdEx-- {
   974  			i -= len(m.Keyspaces[iNdEx])
   975  			copy(dAtA[i:], m.Keyspaces[iNdEx])
   976  			i = encodeVarint(dAtA, i, uint64(len(m.Keyspaces[iNdEx])))
   977  			i--
   978  			dAtA[i] = 0x2a
   979  		}
   980  	}
   981  	if m.Cluster != nil {
   982  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
   983  		if err != nil {
   984  			return 0, err
   985  		}
   986  		i -= size
   987  		i = encodeVarint(dAtA, i, uint64(size))
   988  		i--
   989  		dAtA[i] = 0x22
   990  	}
   991  	if len(m.Cell) > 0 {
   992  		i -= len(m.Cell)
   993  		copy(dAtA[i:], m.Cell)
   994  		i = encodeVarint(dAtA, i, uint64(len(m.Cell)))
   995  		i--
   996  		dAtA[i] = 0x1a
   997  	}
   998  	if len(m.Pool) > 0 {
   999  		i -= len(m.Pool)
  1000  		copy(dAtA[i:], m.Pool)
  1001  		i = encodeVarint(dAtA, i, uint64(len(m.Pool)))
  1002  		i--
  1003  		dAtA[i] = 0x12
  1004  	}
  1005  	if len(m.Hostname) > 0 {
  1006  		i -= len(m.Hostname)
  1007  		copy(dAtA[i:], m.Hostname)
  1008  		i = encodeVarint(dAtA, i, uint64(len(m.Hostname)))
  1009  		i--
  1010  		dAtA[i] = 0xa
  1011  	}
  1012  	return len(dAtA) - i, nil
  1013  }
  1014  
  1015  func (m *Workflow) MarshalVT() (dAtA []byte, err error) {
  1016  	if m == nil {
  1017  		return nil, nil
  1018  	}
  1019  	size := m.SizeVT()
  1020  	dAtA = make([]byte, size)
  1021  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1022  	if err != nil {
  1023  		return nil, err
  1024  	}
  1025  	return dAtA[:n], nil
  1026  }
  1027  
  1028  func (m *Workflow) MarshalToVT(dAtA []byte) (int, error) {
  1029  	size := m.SizeVT()
  1030  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1031  }
  1032  
  1033  func (m *Workflow) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1034  	if m == nil {
  1035  		return 0, nil
  1036  	}
  1037  	i := len(dAtA)
  1038  	_ = i
  1039  	var l int
  1040  	_ = l
  1041  	if m.unknownFields != nil {
  1042  		i -= len(m.unknownFields)
  1043  		copy(dAtA[i:], m.unknownFields)
  1044  	}
  1045  	if m.Workflow != nil {
  1046  		size, err := m.Workflow.MarshalToSizedBufferVT(dAtA[:i])
  1047  		if err != nil {
  1048  			return 0, err
  1049  		}
  1050  		i -= size
  1051  		i = encodeVarint(dAtA, i, uint64(size))
  1052  		i--
  1053  		dAtA[i] = 0x1a
  1054  	}
  1055  	if len(m.Keyspace) > 0 {
  1056  		i -= len(m.Keyspace)
  1057  		copy(dAtA[i:], m.Keyspace)
  1058  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  1059  		i--
  1060  		dAtA[i] = 0x12
  1061  	}
  1062  	if m.Cluster != nil {
  1063  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  1064  		if err != nil {
  1065  			return 0, err
  1066  		}
  1067  		i -= size
  1068  		i = encodeVarint(dAtA, i, uint64(size))
  1069  		i--
  1070  		dAtA[i] = 0xa
  1071  	}
  1072  	return len(dAtA) - i, nil
  1073  }
  1074  
  1075  func (m *CreateKeyspaceRequest) MarshalVT() (dAtA []byte, err error) {
  1076  	if m == nil {
  1077  		return nil, nil
  1078  	}
  1079  	size := m.SizeVT()
  1080  	dAtA = make([]byte, size)
  1081  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1082  	if err != nil {
  1083  		return nil, err
  1084  	}
  1085  	return dAtA[:n], nil
  1086  }
  1087  
  1088  func (m *CreateKeyspaceRequest) MarshalToVT(dAtA []byte) (int, error) {
  1089  	size := m.SizeVT()
  1090  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1091  }
  1092  
  1093  func (m *CreateKeyspaceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1094  	if m == nil {
  1095  		return 0, nil
  1096  	}
  1097  	i := len(dAtA)
  1098  	_ = i
  1099  	var l int
  1100  	_ = l
  1101  	if m.unknownFields != nil {
  1102  		i -= len(m.unknownFields)
  1103  		copy(dAtA[i:], m.unknownFields)
  1104  	}
  1105  	if m.Options != nil {
  1106  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1107  		if err != nil {
  1108  			return 0, err
  1109  		}
  1110  		i -= size
  1111  		i = encodeVarint(dAtA, i, uint64(size))
  1112  		i--
  1113  		dAtA[i] = 0x12
  1114  	}
  1115  	if len(m.ClusterId) > 0 {
  1116  		i -= len(m.ClusterId)
  1117  		copy(dAtA[i:], m.ClusterId)
  1118  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  1119  		i--
  1120  		dAtA[i] = 0xa
  1121  	}
  1122  	return len(dAtA) - i, nil
  1123  }
  1124  
  1125  func (m *CreateKeyspaceResponse) MarshalVT() (dAtA []byte, err error) {
  1126  	if m == nil {
  1127  		return nil, nil
  1128  	}
  1129  	size := m.SizeVT()
  1130  	dAtA = make([]byte, size)
  1131  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1132  	if err != nil {
  1133  		return nil, err
  1134  	}
  1135  	return dAtA[:n], nil
  1136  }
  1137  
  1138  func (m *CreateKeyspaceResponse) MarshalToVT(dAtA []byte) (int, error) {
  1139  	size := m.SizeVT()
  1140  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1141  }
  1142  
  1143  func (m *CreateKeyspaceResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1144  	if m == nil {
  1145  		return 0, nil
  1146  	}
  1147  	i := len(dAtA)
  1148  	_ = i
  1149  	var l int
  1150  	_ = l
  1151  	if m.unknownFields != nil {
  1152  		i -= len(m.unknownFields)
  1153  		copy(dAtA[i:], m.unknownFields)
  1154  	}
  1155  	if m.Keyspace != nil {
  1156  		size, err := m.Keyspace.MarshalToSizedBufferVT(dAtA[:i])
  1157  		if err != nil {
  1158  			return 0, err
  1159  		}
  1160  		i -= size
  1161  		i = encodeVarint(dAtA, i, uint64(size))
  1162  		i--
  1163  		dAtA[i] = 0xa
  1164  	}
  1165  	return len(dAtA) - i, nil
  1166  }
  1167  
  1168  func (m *CreateShardRequest) MarshalVT() (dAtA []byte, err error) {
  1169  	if m == nil {
  1170  		return nil, nil
  1171  	}
  1172  	size := m.SizeVT()
  1173  	dAtA = make([]byte, size)
  1174  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1175  	if err != nil {
  1176  		return nil, err
  1177  	}
  1178  	return dAtA[:n], nil
  1179  }
  1180  
  1181  func (m *CreateShardRequest) MarshalToVT(dAtA []byte) (int, error) {
  1182  	size := m.SizeVT()
  1183  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1184  }
  1185  
  1186  func (m *CreateShardRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1187  	if m == nil {
  1188  		return 0, nil
  1189  	}
  1190  	i := len(dAtA)
  1191  	_ = i
  1192  	var l int
  1193  	_ = l
  1194  	if m.unknownFields != nil {
  1195  		i -= len(m.unknownFields)
  1196  		copy(dAtA[i:], m.unknownFields)
  1197  	}
  1198  	if m.Options != nil {
  1199  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1200  		if err != nil {
  1201  			return 0, err
  1202  		}
  1203  		i -= size
  1204  		i = encodeVarint(dAtA, i, uint64(size))
  1205  		i--
  1206  		dAtA[i] = 0x12
  1207  	}
  1208  	if len(m.ClusterId) > 0 {
  1209  		i -= len(m.ClusterId)
  1210  		copy(dAtA[i:], m.ClusterId)
  1211  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  1212  		i--
  1213  		dAtA[i] = 0xa
  1214  	}
  1215  	return len(dAtA) - i, nil
  1216  }
  1217  
  1218  func (m *DeleteKeyspaceRequest) MarshalVT() (dAtA []byte, err error) {
  1219  	if m == nil {
  1220  		return nil, nil
  1221  	}
  1222  	size := m.SizeVT()
  1223  	dAtA = make([]byte, size)
  1224  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1225  	if err != nil {
  1226  		return nil, err
  1227  	}
  1228  	return dAtA[:n], nil
  1229  }
  1230  
  1231  func (m *DeleteKeyspaceRequest) MarshalToVT(dAtA []byte) (int, error) {
  1232  	size := m.SizeVT()
  1233  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1234  }
  1235  
  1236  func (m *DeleteKeyspaceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1237  	if m == nil {
  1238  		return 0, nil
  1239  	}
  1240  	i := len(dAtA)
  1241  	_ = i
  1242  	var l int
  1243  	_ = l
  1244  	if m.unknownFields != nil {
  1245  		i -= len(m.unknownFields)
  1246  		copy(dAtA[i:], m.unknownFields)
  1247  	}
  1248  	if m.Options != nil {
  1249  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1250  		if err != nil {
  1251  			return 0, err
  1252  		}
  1253  		i -= size
  1254  		i = encodeVarint(dAtA, i, uint64(size))
  1255  		i--
  1256  		dAtA[i] = 0x12
  1257  	}
  1258  	if len(m.ClusterId) > 0 {
  1259  		i -= len(m.ClusterId)
  1260  		copy(dAtA[i:], m.ClusterId)
  1261  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  1262  		i--
  1263  		dAtA[i] = 0xa
  1264  	}
  1265  	return len(dAtA) - i, nil
  1266  }
  1267  
  1268  func (m *DeleteShardsRequest) MarshalVT() (dAtA []byte, err error) {
  1269  	if m == nil {
  1270  		return nil, nil
  1271  	}
  1272  	size := m.SizeVT()
  1273  	dAtA = make([]byte, size)
  1274  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1275  	if err != nil {
  1276  		return nil, err
  1277  	}
  1278  	return dAtA[:n], nil
  1279  }
  1280  
  1281  func (m *DeleteShardsRequest) MarshalToVT(dAtA []byte) (int, error) {
  1282  	size := m.SizeVT()
  1283  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1284  }
  1285  
  1286  func (m *DeleteShardsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1287  	if m == nil {
  1288  		return 0, nil
  1289  	}
  1290  	i := len(dAtA)
  1291  	_ = i
  1292  	var l int
  1293  	_ = l
  1294  	if m.unknownFields != nil {
  1295  		i -= len(m.unknownFields)
  1296  		copy(dAtA[i:], m.unknownFields)
  1297  	}
  1298  	if m.Options != nil {
  1299  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1300  		if err != nil {
  1301  			return 0, err
  1302  		}
  1303  		i -= size
  1304  		i = encodeVarint(dAtA, i, uint64(size))
  1305  		i--
  1306  		dAtA[i] = 0x12
  1307  	}
  1308  	if len(m.ClusterId) > 0 {
  1309  		i -= len(m.ClusterId)
  1310  		copy(dAtA[i:], m.ClusterId)
  1311  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  1312  		i--
  1313  		dAtA[i] = 0xa
  1314  	}
  1315  	return len(dAtA) - i, nil
  1316  }
  1317  
  1318  func (m *DeleteTabletRequest) MarshalVT() (dAtA []byte, err error) {
  1319  	if m == nil {
  1320  		return nil, nil
  1321  	}
  1322  	size := m.SizeVT()
  1323  	dAtA = make([]byte, size)
  1324  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1325  	if err != nil {
  1326  		return nil, err
  1327  	}
  1328  	return dAtA[:n], nil
  1329  }
  1330  
  1331  func (m *DeleteTabletRequest) MarshalToVT(dAtA []byte) (int, error) {
  1332  	size := m.SizeVT()
  1333  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1334  }
  1335  
  1336  func (m *DeleteTabletRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1337  	if m == nil {
  1338  		return 0, nil
  1339  	}
  1340  	i := len(dAtA)
  1341  	_ = i
  1342  	var l int
  1343  	_ = l
  1344  	if m.unknownFields != nil {
  1345  		i -= len(m.unknownFields)
  1346  		copy(dAtA[i:], m.unknownFields)
  1347  	}
  1348  	if m.AllowPrimary {
  1349  		i--
  1350  		if m.AllowPrimary {
  1351  			dAtA[i] = 1
  1352  		} else {
  1353  			dAtA[i] = 0
  1354  		}
  1355  		i--
  1356  		dAtA[i] = 0x18
  1357  	}
  1358  	if len(m.ClusterIds) > 0 {
  1359  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  1360  			i -= len(m.ClusterIds[iNdEx])
  1361  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  1362  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  1363  			i--
  1364  			dAtA[i] = 0x12
  1365  		}
  1366  	}
  1367  	if m.Alias != nil {
  1368  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  1369  		if err != nil {
  1370  			return 0, err
  1371  		}
  1372  		i -= size
  1373  		i = encodeVarint(dAtA, i, uint64(size))
  1374  		i--
  1375  		dAtA[i] = 0xa
  1376  	}
  1377  	return len(dAtA) - i, nil
  1378  }
  1379  
  1380  func (m *DeleteTabletResponse) MarshalVT() (dAtA []byte, err error) {
  1381  	if m == nil {
  1382  		return nil, nil
  1383  	}
  1384  	size := m.SizeVT()
  1385  	dAtA = make([]byte, size)
  1386  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1387  	if err != nil {
  1388  		return nil, err
  1389  	}
  1390  	return dAtA[:n], nil
  1391  }
  1392  
  1393  func (m *DeleteTabletResponse) MarshalToVT(dAtA []byte) (int, error) {
  1394  	size := m.SizeVT()
  1395  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1396  }
  1397  
  1398  func (m *DeleteTabletResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1399  	if m == nil {
  1400  		return 0, nil
  1401  	}
  1402  	i := len(dAtA)
  1403  	_ = i
  1404  	var l int
  1405  	_ = l
  1406  	if m.unknownFields != nil {
  1407  		i -= len(m.unknownFields)
  1408  		copy(dAtA[i:], m.unknownFields)
  1409  	}
  1410  	if m.Cluster != nil {
  1411  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  1412  		if err != nil {
  1413  			return 0, err
  1414  		}
  1415  		i -= size
  1416  		i = encodeVarint(dAtA, i, uint64(size))
  1417  		i--
  1418  		dAtA[i] = 0x12
  1419  	}
  1420  	if len(m.Status) > 0 {
  1421  		i -= len(m.Status)
  1422  		copy(dAtA[i:], m.Status)
  1423  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  1424  		i--
  1425  		dAtA[i] = 0xa
  1426  	}
  1427  	return len(dAtA) - i, nil
  1428  }
  1429  
  1430  func (m *EmergencyFailoverShardRequest) MarshalVT() (dAtA []byte, err error) {
  1431  	if m == nil {
  1432  		return nil, nil
  1433  	}
  1434  	size := m.SizeVT()
  1435  	dAtA = make([]byte, size)
  1436  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1437  	if err != nil {
  1438  		return nil, err
  1439  	}
  1440  	return dAtA[:n], nil
  1441  }
  1442  
  1443  func (m *EmergencyFailoverShardRequest) MarshalToVT(dAtA []byte) (int, error) {
  1444  	size := m.SizeVT()
  1445  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1446  }
  1447  
  1448  func (m *EmergencyFailoverShardRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1449  	if m == nil {
  1450  		return 0, nil
  1451  	}
  1452  	i := len(dAtA)
  1453  	_ = i
  1454  	var l int
  1455  	_ = l
  1456  	if m.unknownFields != nil {
  1457  		i -= len(m.unknownFields)
  1458  		copy(dAtA[i:], m.unknownFields)
  1459  	}
  1460  	if m.Options != nil {
  1461  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  1462  		if err != nil {
  1463  			return 0, err
  1464  		}
  1465  		i -= size
  1466  		i = encodeVarint(dAtA, i, uint64(size))
  1467  		i--
  1468  		dAtA[i] = 0x12
  1469  	}
  1470  	if len(m.ClusterId) > 0 {
  1471  		i -= len(m.ClusterId)
  1472  		copy(dAtA[i:], m.ClusterId)
  1473  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  1474  		i--
  1475  		dAtA[i] = 0xa
  1476  	}
  1477  	return len(dAtA) - i, nil
  1478  }
  1479  
  1480  func (m *EmergencyFailoverShardResponse) MarshalVT() (dAtA []byte, err error) {
  1481  	if m == nil {
  1482  		return nil, nil
  1483  	}
  1484  	size := m.SizeVT()
  1485  	dAtA = make([]byte, size)
  1486  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1487  	if err != nil {
  1488  		return nil, err
  1489  	}
  1490  	return dAtA[:n], nil
  1491  }
  1492  
  1493  func (m *EmergencyFailoverShardResponse) MarshalToVT(dAtA []byte) (int, error) {
  1494  	size := m.SizeVT()
  1495  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1496  }
  1497  
  1498  func (m *EmergencyFailoverShardResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1499  	if m == nil {
  1500  		return 0, nil
  1501  	}
  1502  	i := len(dAtA)
  1503  	_ = i
  1504  	var l int
  1505  	_ = l
  1506  	if m.unknownFields != nil {
  1507  		i -= len(m.unknownFields)
  1508  		copy(dAtA[i:], m.unknownFields)
  1509  	}
  1510  	if len(m.Events) > 0 {
  1511  		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
  1512  			size, err := m.Events[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1513  			if err != nil {
  1514  				return 0, err
  1515  			}
  1516  			i -= size
  1517  			i = encodeVarint(dAtA, i, uint64(size))
  1518  			i--
  1519  			dAtA[i] = 0x2a
  1520  		}
  1521  	}
  1522  	if m.PromotedPrimary != nil {
  1523  		size, err := m.PromotedPrimary.MarshalToSizedBufferVT(dAtA[:i])
  1524  		if err != nil {
  1525  			return 0, err
  1526  		}
  1527  		i -= size
  1528  		i = encodeVarint(dAtA, i, uint64(size))
  1529  		i--
  1530  		dAtA[i] = 0x22
  1531  	}
  1532  	if len(m.Shard) > 0 {
  1533  		i -= len(m.Shard)
  1534  		copy(dAtA[i:], m.Shard)
  1535  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  1536  		i--
  1537  		dAtA[i] = 0x1a
  1538  	}
  1539  	if len(m.Keyspace) > 0 {
  1540  		i -= len(m.Keyspace)
  1541  		copy(dAtA[i:], m.Keyspace)
  1542  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  1543  		i--
  1544  		dAtA[i] = 0x12
  1545  	}
  1546  	if m.Cluster != nil {
  1547  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  1548  		if err != nil {
  1549  			return 0, err
  1550  		}
  1551  		i -= size
  1552  		i = encodeVarint(dAtA, i, uint64(size))
  1553  		i--
  1554  		dAtA[i] = 0xa
  1555  	}
  1556  	return len(dAtA) - i, nil
  1557  }
  1558  
  1559  func (m *FindSchemaRequest) MarshalVT() (dAtA []byte, err error) {
  1560  	if m == nil {
  1561  		return nil, nil
  1562  	}
  1563  	size := m.SizeVT()
  1564  	dAtA = make([]byte, size)
  1565  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1566  	if err != nil {
  1567  		return nil, err
  1568  	}
  1569  	return dAtA[:n], nil
  1570  }
  1571  
  1572  func (m *FindSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  1573  	size := m.SizeVT()
  1574  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1575  }
  1576  
  1577  func (m *FindSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1578  	if m == nil {
  1579  		return 0, nil
  1580  	}
  1581  	i := len(dAtA)
  1582  	_ = i
  1583  	var l int
  1584  	_ = l
  1585  	if m.unknownFields != nil {
  1586  		i -= len(m.unknownFields)
  1587  		copy(dAtA[i:], m.unknownFields)
  1588  	}
  1589  	if m.TableSizeOptions != nil {
  1590  		size, err := m.TableSizeOptions.MarshalToSizedBufferVT(dAtA[:i])
  1591  		if err != nil {
  1592  			return 0, err
  1593  		}
  1594  		i -= size
  1595  		i = encodeVarint(dAtA, i, uint64(size))
  1596  		i--
  1597  		dAtA[i] = 0x1a
  1598  	}
  1599  	if len(m.ClusterIds) > 0 {
  1600  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  1601  			i -= len(m.ClusterIds[iNdEx])
  1602  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  1603  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  1604  			i--
  1605  			dAtA[i] = 0x12
  1606  		}
  1607  	}
  1608  	if len(m.Table) > 0 {
  1609  		i -= len(m.Table)
  1610  		copy(dAtA[i:], m.Table)
  1611  		i = encodeVarint(dAtA, i, uint64(len(m.Table)))
  1612  		i--
  1613  		dAtA[i] = 0xa
  1614  	}
  1615  	return len(dAtA) - i, nil
  1616  }
  1617  
  1618  func (m *GetBackupsRequest) MarshalVT() (dAtA []byte, err error) {
  1619  	if m == nil {
  1620  		return nil, nil
  1621  	}
  1622  	size := m.SizeVT()
  1623  	dAtA = make([]byte, size)
  1624  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1625  	if err != nil {
  1626  		return nil, err
  1627  	}
  1628  	return dAtA[:n], nil
  1629  }
  1630  
  1631  func (m *GetBackupsRequest) MarshalToVT(dAtA []byte) (int, error) {
  1632  	size := m.SizeVT()
  1633  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1634  }
  1635  
  1636  func (m *GetBackupsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1637  	if m == nil {
  1638  		return 0, nil
  1639  	}
  1640  	i := len(dAtA)
  1641  	_ = i
  1642  	var l int
  1643  	_ = l
  1644  	if m.unknownFields != nil {
  1645  		i -= len(m.unknownFields)
  1646  		copy(dAtA[i:], m.unknownFields)
  1647  	}
  1648  	if m.RequestOptions != nil {
  1649  		size, err := m.RequestOptions.MarshalToSizedBufferVT(dAtA[:i])
  1650  		if err != nil {
  1651  			return 0, err
  1652  		}
  1653  		i -= size
  1654  		i = encodeVarint(dAtA, i, uint64(size))
  1655  		i--
  1656  		dAtA[i] = 0x22
  1657  	}
  1658  	if len(m.KeyspaceShards) > 0 {
  1659  		for iNdEx := len(m.KeyspaceShards) - 1; iNdEx >= 0; iNdEx-- {
  1660  			i -= len(m.KeyspaceShards[iNdEx])
  1661  			copy(dAtA[i:], m.KeyspaceShards[iNdEx])
  1662  			i = encodeVarint(dAtA, i, uint64(len(m.KeyspaceShards[iNdEx])))
  1663  			i--
  1664  			dAtA[i] = 0x1a
  1665  		}
  1666  	}
  1667  	if len(m.Keyspaces) > 0 {
  1668  		for iNdEx := len(m.Keyspaces) - 1; iNdEx >= 0; iNdEx-- {
  1669  			i -= len(m.Keyspaces[iNdEx])
  1670  			copy(dAtA[i:], m.Keyspaces[iNdEx])
  1671  			i = encodeVarint(dAtA, i, uint64(len(m.Keyspaces[iNdEx])))
  1672  			i--
  1673  			dAtA[i] = 0x12
  1674  		}
  1675  	}
  1676  	if len(m.ClusterIds) > 0 {
  1677  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  1678  			i -= len(m.ClusterIds[iNdEx])
  1679  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  1680  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  1681  			i--
  1682  			dAtA[i] = 0xa
  1683  		}
  1684  	}
  1685  	return len(dAtA) - i, nil
  1686  }
  1687  
  1688  func (m *GetBackupsResponse) MarshalVT() (dAtA []byte, err error) {
  1689  	if m == nil {
  1690  		return nil, nil
  1691  	}
  1692  	size := m.SizeVT()
  1693  	dAtA = make([]byte, size)
  1694  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1695  	if err != nil {
  1696  		return nil, err
  1697  	}
  1698  	return dAtA[:n], nil
  1699  }
  1700  
  1701  func (m *GetBackupsResponse) MarshalToVT(dAtA []byte) (int, error) {
  1702  	size := m.SizeVT()
  1703  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1704  }
  1705  
  1706  func (m *GetBackupsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1707  	if m == nil {
  1708  		return 0, nil
  1709  	}
  1710  	i := len(dAtA)
  1711  	_ = i
  1712  	var l int
  1713  	_ = l
  1714  	if m.unknownFields != nil {
  1715  		i -= len(m.unknownFields)
  1716  		copy(dAtA[i:], m.unknownFields)
  1717  	}
  1718  	if len(m.Backups) > 0 {
  1719  		for iNdEx := len(m.Backups) - 1; iNdEx >= 0; iNdEx-- {
  1720  			size, err := m.Backups[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1721  			if err != nil {
  1722  				return 0, err
  1723  			}
  1724  			i -= size
  1725  			i = encodeVarint(dAtA, i, uint64(size))
  1726  			i--
  1727  			dAtA[i] = 0xa
  1728  		}
  1729  	}
  1730  	return len(dAtA) - i, nil
  1731  }
  1732  
  1733  func (m *GetCellInfosRequest) MarshalVT() (dAtA []byte, err error) {
  1734  	if m == nil {
  1735  		return nil, nil
  1736  	}
  1737  	size := m.SizeVT()
  1738  	dAtA = make([]byte, size)
  1739  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1740  	if err != nil {
  1741  		return nil, err
  1742  	}
  1743  	return dAtA[:n], nil
  1744  }
  1745  
  1746  func (m *GetCellInfosRequest) MarshalToVT(dAtA []byte) (int, error) {
  1747  	size := m.SizeVT()
  1748  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1749  }
  1750  
  1751  func (m *GetCellInfosRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1752  	if m == nil {
  1753  		return 0, nil
  1754  	}
  1755  	i := len(dAtA)
  1756  	_ = i
  1757  	var l int
  1758  	_ = l
  1759  	if m.unknownFields != nil {
  1760  		i -= len(m.unknownFields)
  1761  		copy(dAtA[i:], m.unknownFields)
  1762  	}
  1763  	if m.NamesOnly {
  1764  		i--
  1765  		if m.NamesOnly {
  1766  			dAtA[i] = 1
  1767  		} else {
  1768  			dAtA[i] = 0
  1769  		}
  1770  		i--
  1771  		dAtA[i] = 0x18
  1772  	}
  1773  	if len(m.Cells) > 0 {
  1774  		for iNdEx := len(m.Cells) - 1; iNdEx >= 0; iNdEx-- {
  1775  			i -= len(m.Cells[iNdEx])
  1776  			copy(dAtA[i:], m.Cells[iNdEx])
  1777  			i = encodeVarint(dAtA, i, uint64(len(m.Cells[iNdEx])))
  1778  			i--
  1779  			dAtA[i] = 0x12
  1780  		}
  1781  	}
  1782  	if len(m.ClusterIds) > 0 {
  1783  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  1784  			i -= len(m.ClusterIds[iNdEx])
  1785  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  1786  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  1787  			i--
  1788  			dAtA[i] = 0xa
  1789  		}
  1790  	}
  1791  	return len(dAtA) - i, nil
  1792  }
  1793  
  1794  func (m *GetCellInfosResponse) MarshalVT() (dAtA []byte, err error) {
  1795  	if m == nil {
  1796  		return nil, nil
  1797  	}
  1798  	size := m.SizeVT()
  1799  	dAtA = make([]byte, size)
  1800  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1801  	if err != nil {
  1802  		return nil, err
  1803  	}
  1804  	return dAtA[:n], nil
  1805  }
  1806  
  1807  func (m *GetCellInfosResponse) MarshalToVT(dAtA []byte) (int, error) {
  1808  	size := m.SizeVT()
  1809  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1810  }
  1811  
  1812  func (m *GetCellInfosResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1813  	if m == nil {
  1814  		return 0, nil
  1815  	}
  1816  	i := len(dAtA)
  1817  	_ = i
  1818  	var l int
  1819  	_ = l
  1820  	if m.unknownFields != nil {
  1821  		i -= len(m.unknownFields)
  1822  		copy(dAtA[i:], m.unknownFields)
  1823  	}
  1824  	if len(m.CellInfos) > 0 {
  1825  		for iNdEx := len(m.CellInfos) - 1; iNdEx >= 0; iNdEx-- {
  1826  			size, err := m.CellInfos[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1827  			if err != nil {
  1828  				return 0, err
  1829  			}
  1830  			i -= size
  1831  			i = encodeVarint(dAtA, i, uint64(size))
  1832  			i--
  1833  			dAtA[i] = 0xa
  1834  		}
  1835  	}
  1836  	return len(dAtA) - i, nil
  1837  }
  1838  
  1839  func (m *GetCellsAliasesRequest) MarshalVT() (dAtA []byte, err error) {
  1840  	if m == nil {
  1841  		return nil, nil
  1842  	}
  1843  	size := m.SizeVT()
  1844  	dAtA = make([]byte, size)
  1845  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1846  	if err != nil {
  1847  		return nil, err
  1848  	}
  1849  	return dAtA[:n], nil
  1850  }
  1851  
  1852  func (m *GetCellsAliasesRequest) MarshalToVT(dAtA []byte) (int, error) {
  1853  	size := m.SizeVT()
  1854  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1855  }
  1856  
  1857  func (m *GetCellsAliasesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1858  	if m == nil {
  1859  		return 0, nil
  1860  	}
  1861  	i := len(dAtA)
  1862  	_ = i
  1863  	var l int
  1864  	_ = l
  1865  	if m.unknownFields != nil {
  1866  		i -= len(m.unknownFields)
  1867  		copy(dAtA[i:], m.unknownFields)
  1868  	}
  1869  	if len(m.ClusterIds) > 0 {
  1870  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  1871  			i -= len(m.ClusterIds[iNdEx])
  1872  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  1873  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  1874  			i--
  1875  			dAtA[i] = 0xa
  1876  		}
  1877  	}
  1878  	return len(dAtA) - i, nil
  1879  }
  1880  
  1881  func (m *GetCellsAliasesResponse) MarshalVT() (dAtA []byte, err error) {
  1882  	if m == nil {
  1883  		return nil, nil
  1884  	}
  1885  	size := m.SizeVT()
  1886  	dAtA = make([]byte, size)
  1887  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1888  	if err != nil {
  1889  		return nil, err
  1890  	}
  1891  	return dAtA[:n], nil
  1892  }
  1893  
  1894  func (m *GetCellsAliasesResponse) MarshalToVT(dAtA []byte) (int, error) {
  1895  	size := m.SizeVT()
  1896  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1897  }
  1898  
  1899  func (m *GetCellsAliasesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1900  	if m == nil {
  1901  		return 0, nil
  1902  	}
  1903  	i := len(dAtA)
  1904  	_ = i
  1905  	var l int
  1906  	_ = l
  1907  	if m.unknownFields != nil {
  1908  		i -= len(m.unknownFields)
  1909  		copy(dAtA[i:], m.unknownFields)
  1910  	}
  1911  	if len(m.Aliases) > 0 {
  1912  		for iNdEx := len(m.Aliases) - 1; iNdEx >= 0; iNdEx-- {
  1913  			size, err := m.Aliases[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1914  			if err != nil {
  1915  				return 0, err
  1916  			}
  1917  			i -= size
  1918  			i = encodeVarint(dAtA, i, uint64(size))
  1919  			i--
  1920  			dAtA[i] = 0xa
  1921  		}
  1922  	}
  1923  	return len(dAtA) - i, nil
  1924  }
  1925  
  1926  func (m *GetClustersRequest) MarshalVT() (dAtA []byte, err error) {
  1927  	if m == nil {
  1928  		return nil, nil
  1929  	}
  1930  	size := m.SizeVT()
  1931  	dAtA = make([]byte, size)
  1932  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1933  	if err != nil {
  1934  		return nil, err
  1935  	}
  1936  	return dAtA[:n], nil
  1937  }
  1938  
  1939  func (m *GetClustersRequest) MarshalToVT(dAtA []byte) (int, error) {
  1940  	size := m.SizeVT()
  1941  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1942  }
  1943  
  1944  func (m *GetClustersRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1945  	if m == nil {
  1946  		return 0, nil
  1947  	}
  1948  	i := len(dAtA)
  1949  	_ = i
  1950  	var l int
  1951  	_ = l
  1952  	if m.unknownFields != nil {
  1953  		i -= len(m.unknownFields)
  1954  		copy(dAtA[i:], m.unknownFields)
  1955  	}
  1956  	return len(dAtA) - i, nil
  1957  }
  1958  
  1959  func (m *GetClustersResponse) MarshalVT() (dAtA []byte, err error) {
  1960  	if m == nil {
  1961  		return nil, nil
  1962  	}
  1963  	size := m.SizeVT()
  1964  	dAtA = make([]byte, size)
  1965  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1966  	if err != nil {
  1967  		return nil, err
  1968  	}
  1969  	return dAtA[:n], nil
  1970  }
  1971  
  1972  func (m *GetClustersResponse) MarshalToVT(dAtA []byte) (int, error) {
  1973  	size := m.SizeVT()
  1974  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1975  }
  1976  
  1977  func (m *GetClustersResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1978  	if m == nil {
  1979  		return 0, nil
  1980  	}
  1981  	i := len(dAtA)
  1982  	_ = i
  1983  	var l int
  1984  	_ = l
  1985  	if m.unknownFields != nil {
  1986  		i -= len(m.unknownFields)
  1987  		copy(dAtA[i:], m.unknownFields)
  1988  	}
  1989  	if len(m.Clusters) > 0 {
  1990  		for iNdEx := len(m.Clusters) - 1; iNdEx >= 0; iNdEx-- {
  1991  			size, err := m.Clusters[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1992  			if err != nil {
  1993  				return 0, err
  1994  			}
  1995  			i -= size
  1996  			i = encodeVarint(dAtA, i, uint64(size))
  1997  			i--
  1998  			dAtA[i] = 0xa
  1999  		}
  2000  	}
  2001  	return len(dAtA) - i, nil
  2002  }
  2003  
  2004  func (m *GetFullStatusRequest) MarshalVT() (dAtA []byte, err error) {
  2005  	if m == nil {
  2006  		return nil, nil
  2007  	}
  2008  	size := m.SizeVT()
  2009  	dAtA = make([]byte, size)
  2010  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2011  	if err != nil {
  2012  		return nil, err
  2013  	}
  2014  	return dAtA[:n], nil
  2015  }
  2016  
  2017  func (m *GetFullStatusRequest) MarshalToVT(dAtA []byte) (int, error) {
  2018  	size := m.SizeVT()
  2019  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2020  }
  2021  
  2022  func (m *GetFullStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2023  	if m == nil {
  2024  		return 0, nil
  2025  	}
  2026  	i := len(dAtA)
  2027  	_ = i
  2028  	var l int
  2029  	_ = l
  2030  	if m.unknownFields != nil {
  2031  		i -= len(m.unknownFields)
  2032  		copy(dAtA[i:], m.unknownFields)
  2033  	}
  2034  	if m.Alias != nil {
  2035  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  2036  		if err != nil {
  2037  			return 0, err
  2038  		}
  2039  		i -= size
  2040  		i = encodeVarint(dAtA, i, uint64(size))
  2041  		i--
  2042  		dAtA[i] = 0x12
  2043  	}
  2044  	if len(m.ClusterId) > 0 {
  2045  		i -= len(m.ClusterId)
  2046  		copy(dAtA[i:], m.ClusterId)
  2047  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  2048  		i--
  2049  		dAtA[i] = 0xa
  2050  	}
  2051  	return len(dAtA) - i, nil
  2052  }
  2053  
  2054  func (m *GetGatesRequest) MarshalVT() (dAtA []byte, err error) {
  2055  	if m == nil {
  2056  		return nil, nil
  2057  	}
  2058  	size := m.SizeVT()
  2059  	dAtA = make([]byte, size)
  2060  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2061  	if err != nil {
  2062  		return nil, err
  2063  	}
  2064  	return dAtA[:n], nil
  2065  }
  2066  
  2067  func (m *GetGatesRequest) MarshalToVT(dAtA []byte) (int, error) {
  2068  	size := m.SizeVT()
  2069  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2070  }
  2071  
  2072  func (m *GetGatesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2073  	if m == nil {
  2074  		return 0, nil
  2075  	}
  2076  	i := len(dAtA)
  2077  	_ = i
  2078  	var l int
  2079  	_ = l
  2080  	if m.unknownFields != nil {
  2081  		i -= len(m.unknownFields)
  2082  		copy(dAtA[i:], m.unknownFields)
  2083  	}
  2084  	if len(m.ClusterIds) > 0 {
  2085  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2086  			i -= len(m.ClusterIds[iNdEx])
  2087  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2088  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2089  			i--
  2090  			dAtA[i] = 0xa
  2091  		}
  2092  	}
  2093  	return len(dAtA) - i, nil
  2094  }
  2095  
  2096  func (m *GetGatesResponse) MarshalVT() (dAtA []byte, err error) {
  2097  	if m == nil {
  2098  		return nil, nil
  2099  	}
  2100  	size := m.SizeVT()
  2101  	dAtA = make([]byte, size)
  2102  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2103  	if err != nil {
  2104  		return nil, err
  2105  	}
  2106  	return dAtA[:n], nil
  2107  }
  2108  
  2109  func (m *GetGatesResponse) MarshalToVT(dAtA []byte) (int, error) {
  2110  	size := m.SizeVT()
  2111  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2112  }
  2113  
  2114  func (m *GetGatesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2115  	if m == nil {
  2116  		return 0, nil
  2117  	}
  2118  	i := len(dAtA)
  2119  	_ = i
  2120  	var l int
  2121  	_ = l
  2122  	if m.unknownFields != nil {
  2123  		i -= len(m.unknownFields)
  2124  		copy(dAtA[i:], m.unknownFields)
  2125  	}
  2126  	if len(m.Gates) > 0 {
  2127  		for iNdEx := len(m.Gates) - 1; iNdEx >= 0; iNdEx-- {
  2128  			size, err := m.Gates[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2129  			if err != nil {
  2130  				return 0, err
  2131  			}
  2132  			i -= size
  2133  			i = encodeVarint(dAtA, i, uint64(size))
  2134  			i--
  2135  			dAtA[i] = 0xa
  2136  		}
  2137  	}
  2138  	return len(dAtA) - i, nil
  2139  }
  2140  
  2141  func (m *GetKeyspaceRequest) MarshalVT() (dAtA []byte, err error) {
  2142  	if m == nil {
  2143  		return nil, nil
  2144  	}
  2145  	size := m.SizeVT()
  2146  	dAtA = make([]byte, size)
  2147  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2148  	if err != nil {
  2149  		return nil, err
  2150  	}
  2151  	return dAtA[:n], nil
  2152  }
  2153  
  2154  func (m *GetKeyspaceRequest) MarshalToVT(dAtA []byte) (int, error) {
  2155  	size := m.SizeVT()
  2156  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2157  }
  2158  
  2159  func (m *GetKeyspaceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2160  	if m == nil {
  2161  		return 0, nil
  2162  	}
  2163  	i := len(dAtA)
  2164  	_ = i
  2165  	var l int
  2166  	_ = l
  2167  	if m.unknownFields != nil {
  2168  		i -= len(m.unknownFields)
  2169  		copy(dAtA[i:], m.unknownFields)
  2170  	}
  2171  	if len(m.Keyspace) > 0 {
  2172  		i -= len(m.Keyspace)
  2173  		copy(dAtA[i:], m.Keyspace)
  2174  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  2175  		i--
  2176  		dAtA[i] = 0x12
  2177  	}
  2178  	if len(m.ClusterId) > 0 {
  2179  		i -= len(m.ClusterId)
  2180  		copy(dAtA[i:], m.ClusterId)
  2181  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  2182  		i--
  2183  		dAtA[i] = 0xa
  2184  	}
  2185  	return len(dAtA) - i, nil
  2186  }
  2187  
  2188  func (m *GetKeyspacesRequest) MarshalVT() (dAtA []byte, err error) {
  2189  	if m == nil {
  2190  		return nil, nil
  2191  	}
  2192  	size := m.SizeVT()
  2193  	dAtA = make([]byte, size)
  2194  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2195  	if err != nil {
  2196  		return nil, err
  2197  	}
  2198  	return dAtA[:n], nil
  2199  }
  2200  
  2201  func (m *GetKeyspacesRequest) MarshalToVT(dAtA []byte) (int, error) {
  2202  	size := m.SizeVT()
  2203  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2204  }
  2205  
  2206  func (m *GetKeyspacesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2207  	if m == nil {
  2208  		return 0, nil
  2209  	}
  2210  	i := len(dAtA)
  2211  	_ = i
  2212  	var l int
  2213  	_ = l
  2214  	if m.unknownFields != nil {
  2215  		i -= len(m.unknownFields)
  2216  		copy(dAtA[i:], m.unknownFields)
  2217  	}
  2218  	if len(m.ClusterIds) > 0 {
  2219  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2220  			i -= len(m.ClusterIds[iNdEx])
  2221  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2222  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2223  			i--
  2224  			dAtA[i] = 0xa
  2225  		}
  2226  	}
  2227  	return len(dAtA) - i, nil
  2228  }
  2229  
  2230  func (m *GetKeyspacesResponse) MarshalVT() (dAtA []byte, err error) {
  2231  	if m == nil {
  2232  		return nil, nil
  2233  	}
  2234  	size := m.SizeVT()
  2235  	dAtA = make([]byte, size)
  2236  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2237  	if err != nil {
  2238  		return nil, err
  2239  	}
  2240  	return dAtA[:n], nil
  2241  }
  2242  
  2243  func (m *GetKeyspacesResponse) MarshalToVT(dAtA []byte) (int, error) {
  2244  	size := m.SizeVT()
  2245  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2246  }
  2247  
  2248  func (m *GetKeyspacesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2249  	if m == nil {
  2250  		return 0, nil
  2251  	}
  2252  	i := len(dAtA)
  2253  	_ = i
  2254  	var l int
  2255  	_ = l
  2256  	if m.unknownFields != nil {
  2257  		i -= len(m.unknownFields)
  2258  		copy(dAtA[i:], m.unknownFields)
  2259  	}
  2260  	if len(m.Keyspaces) > 0 {
  2261  		for iNdEx := len(m.Keyspaces) - 1; iNdEx >= 0; iNdEx-- {
  2262  			size, err := m.Keyspaces[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2263  			if err != nil {
  2264  				return 0, err
  2265  			}
  2266  			i -= size
  2267  			i = encodeVarint(dAtA, i, uint64(size))
  2268  			i--
  2269  			dAtA[i] = 0xa
  2270  		}
  2271  	}
  2272  	return len(dAtA) - i, nil
  2273  }
  2274  
  2275  func (m *GetSchemaRequest) MarshalVT() (dAtA []byte, err error) {
  2276  	if m == nil {
  2277  		return nil, nil
  2278  	}
  2279  	size := m.SizeVT()
  2280  	dAtA = make([]byte, size)
  2281  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2282  	if err != nil {
  2283  		return nil, err
  2284  	}
  2285  	return dAtA[:n], nil
  2286  }
  2287  
  2288  func (m *GetSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  2289  	size := m.SizeVT()
  2290  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2291  }
  2292  
  2293  func (m *GetSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2294  	if m == nil {
  2295  		return 0, nil
  2296  	}
  2297  	i := len(dAtA)
  2298  	_ = i
  2299  	var l int
  2300  	_ = l
  2301  	if m.unknownFields != nil {
  2302  		i -= len(m.unknownFields)
  2303  		copy(dAtA[i:], m.unknownFields)
  2304  	}
  2305  	if m.TableSizeOptions != nil {
  2306  		size, err := m.TableSizeOptions.MarshalToSizedBufferVT(dAtA[:i])
  2307  		if err != nil {
  2308  			return 0, err
  2309  		}
  2310  		i -= size
  2311  		i = encodeVarint(dAtA, i, uint64(size))
  2312  		i--
  2313  		dAtA[i] = 0x22
  2314  	}
  2315  	if len(m.Table) > 0 {
  2316  		i -= len(m.Table)
  2317  		copy(dAtA[i:], m.Table)
  2318  		i = encodeVarint(dAtA, i, uint64(len(m.Table)))
  2319  		i--
  2320  		dAtA[i] = 0x1a
  2321  	}
  2322  	if len(m.Keyspace) > 0 {
  2323  		i -= len(m.Keyspace)
  2324  		copy(dAtA[i:], m.Keyspace)
  2325  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  2326  		i--
  2327  		dAtA[i] = 0x12
  2328  	}
  2329  	if len(m.ClusterId) > 0 {
  2330  		i -= len(m.ClusterId)
  2331  		copy(dAtA[i:], m.ClusterId)
  2332  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  2333  		i--
  2334  		dAtA[i] = 0xa
  2335  	}
  2336  	return len(dAtA) - i, nil
  2337  }
  2338  
  2339  func (m *GetSchemasRequest) MarshalVT() (dAtA []byte, err error) {
  2340  	if m == nil {
  2341  		return nil, nil
  2342  	}
  2343  	size := m.SizeVT()
  2344  	dAtA = make([]byte, size)
  2345  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2346  	if err != nil {
  2347  		return nil, err
  2348  	}
  2349  	return dAtA[:n], nil
  2350  }
  2351  
  2352  func (m *GetSchemasRequest) MarshalToVT(dAtA []byte) (int, error) {
  2353  	size := m.SizeVT()
  2354  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2355  }
  2356  
  2357  func (m *GetSchemasRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2358  	if m == nil {
  2359  		return 0, nil
  2360  	}
  2361  	i := len(dAtA)
  2362  	_ = i
  2363  	var l int
  2364  	_ = l
  2365  	if m.unknownFields != nil {
  2366  		i -= len(m.unknownFields)
  2367  		copy(dAtA[i:], m.unknownFields)
  2368  	}
  2369  	if m.TableSizeOptions != nil {
  2370  		size, err := m.TableSizeOptions.MarshalToSizedBufferVT(dAtA[:i])
  2371  		if err != nil {
  2372  			return 0, err
  2373  		}
  2374  		i -= size
  2375  		i = encodeVarint(dAtA, i, uint64(size))
  2376  		i--
  2377  		dAtA[i] = 0x12
  2378  	}
  2379  	if len(m.ClusterIds) > 0 {
  2380  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2381  			i -= len(m.ClusterIds[iNdEx])
  2382  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2383  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2384  			i--
  2385  			dAtA[i] = 0xa
  2386  		}
  2387  	}
  2388  	return len(dAtA) - i, nil
  2389  }
  2390  
  2391  func (m *GetSchemasResponse) MarshalVT() (dAtA []byte, err error) {
  2392  	if m == nil {
  2393  		return nil, nil
  2394  	}
  2395  	size := m.SizeVT()
  2396  	dAtA = make([]byte, size)
  2397  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2398  	if err != nil {
  2399  		return nil, err
  2400  	}
  2401  	return dAtA[:n], nil
  2402  }
  2403  
  2404  func (m *GetSchemasResponse) MarshalToVT(dAtA []byte) (int, error) {
  2405  	size := m.SizeVT()
  2406  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2407  }
  2408  
  2409  func (m *GetSchemasResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2410  	if m == nil {
  2411  		return 0, nil
  2412  	}
  2413  	i := len(dAtA)
  2414  	_ = i
  2415  	var l int
  2416  	_ = l
  2417  	if m.unknownFields != nil {
  2418  		i -= len(m.unknownFields)
  2419  		copy(dAtA[i:], m.unknownFields)
  2420  	}
  2421  	if len(m.Schemas) > 0 {
  2422  		for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- {
  2423  			size, err := m.Schemas[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2424  			if err != nil {
  2425  				return 0, err
  2426  			}
  2427  			i -= size
  2428  			i = encodeVarint(dAtA, i, uint64(size))
  2429  			i--
  2430  			dAtA[i] = 0xa
  2431  		}
  2432  	}
  2433  	return len(dAtA) - i, nil
  2434  }
  2435  
  2436  func (m *GetShardReplicationPositionsRequest) MarshalVT() (dAtA []byte, err error) {
  2437  	if m == nil {
  2438  		return nil, nil
  2439  	}
  2440  	size := m.SizeVT()
  2441  	dAtA = make([]byte, size)
  2442  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2443  	if err != nil {
  2444  		return nil, err
  2445  	}
  2446  	return dAtA[:n], nil
  2447  }
  2448  
  2449  func (m *GetShardReplicationPositionsRequest) MarshalToVT(dAtA []byte) (int, error) {
  2450  	size := m.SizeVT()
  2451  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2452  }
  2453  
  2454  func (m *GetShardReplicationPositionsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2455  	if m == nil {
  2456  		return 0, nil
  2457  	}
  2458  	i := len(dAtA)
  2459  	_ = i
  2460  	var l int
  2461  	_ = l
  2462  	if m.unknownFields != nil {
  2463  		i -= len(m.unknownFields)
  2464  		copy(dAtA[i:], m.unknownFields)
  2465  	}
  2466  	if len(m.KeyspaceShards) > 0 {
  2467  		for iNdEx := len(m.KeyspaceShards) - 1; iNdEx >= 0; iNdEx-- {
  2468  			i -= len(m.KeyspaceShards[iNdEx])
  2469  			copy(dAtA[i:], m.KeyspaceShards[iNdEx])
  2470  			i = encodeVarint(dAtA, i, uint64(len(m.KeyspaceShards[iNdEx])))
  2471  			i--
  2472  			dAtA[i] = 0x1a
  2473  		}
  2474  	}
  2475  	if len(m.Keyspaces) > 0 {
  2476  		for iNdEx := len(m.Keyspaces) - 1; iNdEx >= 0; iNdEx-- {
  2477  			i -= len(m.Keyspaces[iNdEx])
  2478  			copy(dAtA[i:], m.Keyspaces[iNdEx])
  2479  			i = encodeVarint(dAtA, i, uint64(len(m.Keyspaces[iNdEx])))
  2480  			i--
  2481  			dAtA[i] = 0x12
  2482  		}
  2483  	}
  2484  	if len(m.ClusterIds) > 0 {
  2485  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2486  			i -= len(m.ClusterIds[iNdEx])
  2487  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2488  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2489  			i--
  2490  			dAtA[i] = 0xa
  2491  		}
  2492  	}
  2493  	return len(dAtA) - i, nil
  2494  }
  2495  
  2496  func (m *GetShardReplicationPositionsResponse) MarshalVT() (dAtA []byte, err error) {
  2497  	if m == nil {
  2498  		return nil, nil
  2499  	}
  2500  	size := m.SizeVT()
  2501  	dAtA = make([]byte, size)
  2502  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2503  	if err != nil {
  2504  		return nil, err
  2505  	}
  2506  	return dAtA[:n], nil
  2507  }
  2508  
  2509  func (m *GetShardReplicationPositionsResponse) MarshalToVT(dAtA []byte) (int, error) {
  2510  	size := m.SizeVT()
  2511  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2512  }
  2513  
  2514  func (m *GetShardReplicationPositionsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2515  	if m == nil {
  2516  		return 0, nil
  2517  	}
  2518  	i := len(dAtA)
  2519  	_ = i
  2520  	var l int
  2521  	_ = l
  2522  	if m.unknownFields != nil {
  2523  		i -= len(m.unknownFields)
  2524  		copy(dAtA[i:], m.unknownFields)
  2525  	}
  2526  	if len(m.ReplicationPositions) > 0 {
  2527  		for iNdEx := len(m.ReplicationPositions) - 1; iNdEx >= 0; iNdEx-- {
  2528  			size, err := m.ReplicationPositions[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2529  			if err != nil {
  2530  				return 0, err
  2531  			}
  2532  			i -= size
  2533  			i = encodeVarint(dAtA, i, uint64(size))
  2534  			i--
  2535  			dAtA[i] = 0xa
  2536  		}
  2537  	}
  2538  	return len(dAtA) - i, nil
  2539  }
  2540  
  2541  func (m *GetSrvVSchemaRequest) MarshalVT() (dAtA []byte, err error) {
  2542  	if m == nil {
  2543  		return nil, nil
  2544  	}
  2545  	size := m.SizeVT()
  2546  	dAtA = make([]byte, size)
  2547  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2548  	if err != nil {
  2549  		return nil, err
  2550  	}
  2551  	return dAtA[:n], nil
  2552  }
  2553  
  2554  func (m *GetSrvVSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  2555  	size := m.SizeVT()
  2556  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2557  }
  2558  
  2559  func (m *GetSrvVSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2560  	if m == nil {
  2561  		return 0, nil
  2562  	}
  2563  	i := len(dAtA)
  2564  	_ = i
  2565  	var l int
  2566  	_ = l
  2567  	if m.unknownFields != nil {
  2568  		i -= len(m.unknownFields)
  2569  		copy(dAtA[i:], m.unknownFields)
  2570  	}
  2571  	if len(m.Cell) > 0 {
  2572  		i -= len(m.Cell)
  2573  		copy(dAtA[i:], m.Cell)
  2574  		i = encodeVarint(dAtA, i, uint64(len(m.Cell)))
  2575  		i--
  2576  		dAtA[i] = 0x12
  2577  	}
  2578  	if len(m.ClusterId) > 0 {
  2579  		i -= len(m.ClusterId)
  2580  		copy(dAtA[i:], m.ClusterId)
  2581  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  2582  		i--
  2583  		dAtA[i] = 0xa
  2584  	}
  2585  	return len(dAtA) - i, nil
  2586  }
  2587  
  2588  func (m *GetSrvVSchemasRequest) MarshalVT() (dAtA []byte, err error) {
  2589  	if m == nil {
  2590  		return nil, nil
  2591  	}
  2592  	size := m.SizeVT()
  2593  	dAtA = make([]byte, size)
  2594  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2595  	if err != nil {
  2596  		return nil, err
  2597  	}
  2598  	return dAtA[:n], nil
  2599  }
  2600  
  2601  func (m *GetSrvVSchemasRequest) MarshalToVT(dAtA []byte) (int, error) {
  2602  	size := m.SizeVT()
  2603  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2604  }
  2605  
  2606  func (m *GetSrvVSchemasRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2607  	if m == nil {
  2608  		return 0, nil
  2609  	}
  2610  	i := len(dAtA)
  2611  	_ = i
  2612  	var l int
  2613  	_ = l
  2614  	if m.unknownFields != nil {
  2615  		i -= len(m.unknownFields)
  2616  		copy(dAtA[i:], m.unknownFields)
  2617  	}
  2618  	if len(m.Cells) > 0 {
  2619  		for iNdEx := len(m.Cells) - 1; iNdEx >= 0; iNdEx-- {
  2620  			i -= len(m.Cells[iNdEx])
  2621  			copy(dAtA[i:], m.Cells[iNdEx])
  2622  			i = encodeVarint(dAtA, i, uint64(len(m.Cells[iNdEx])))
  2623  			i--
  2624  			dAtA[i] = 0x12
  2625  		}
  2626  	}
  2627  	if len(m.ClusterIds) > 0 {
  2628  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2629  			i -= len(m.ClusterIds[iNdEx])
  2630  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2631  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2632  			i--
  2633  			dAtA[i] = 0xa
  2634  		}
  2635  	}
  2636  	return len(dAtA) - i, nil
  2637  }
  2638  
  2639  func (m *GetSrvVSchemasResponse) MarshalVT() (dAtA []byte, err error) {
  2640  	if m == nil {
  2641  		return nil, nil
  2642  	}
  2643  	size := m.SizeVT()
  2644  	dAtA = make([]byte, size)
  2645  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2646  	if err != nil {
  2647  		return nil, err
  2648  	}
  2649  	return dAtA[:n], nil
  2650  }
  2651  
  2652  func (m *GetSrvVSchemasResponse) MarshalToVT(dAtA []byte) (int, error) {
  2653  	size := m.SizeVT()
  2654  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2655  }
  2656  
  2657  func (m *GetSrvVSchemasResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2658  	if m == nil {
  2659  		return 0, nil
  2660  	}
  2661  	i := len(dAtA)
  2662  	_ = i
  2663  	var l int
  2664  	_ = l
  2665  	if m.unknownFields != nil {
  2666  		i -= len(m.unknownFields)
  2667  		copy(dAtA[i:], m.unknownFields)
  2668  	}
  2669  	if len(m.SrvVSchemas) > 0 {
  2670  		for iNdEx := len(m.SrvVSchemas) - 1; iNdEx >= 0; iNdEx-- {
  2671  			size, err := m.SrvVSchemas[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2672  			if err != nil {
  2673  				return 0, err
  2674  			}
  2675  			i -= size
  2676  			i = encodeVarint(dAtA, i, uint64(size))
  2677  			i--
  2678  			dAtA[i] = 0xa
  2679  		}
  2680  	}
  2681  	return len(dAtA) - i, nil
  2682  }
  2683  
  2684  func (m *GetSchemaTableSizeOptions) MarshalVT() (dAtA []byte, err error) {
  2685  	if m == nil {
  2686  		return nil, nil
  2687  	}
  2688  	size := m.SizeVT()
  2689  	dAtA = make([]byte, size)
  2690  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2691  	if err != nil {
  2692  		return nil, err
  2693  	}
  2694  	return dAtA[:n], nil
  2695  }
  2696  
  2697  func (m *GetSchemaTableSizeOptions) MarshalToVT(dAtA []byte) (int, error) {
  2698  	size := m.SizeVT()
  2699  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2700  }
  2701  
  2702  func (m *GetSchemaTableSizeOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2703  	if m == nil {
  2704  		return 0, nil
  2705  	}
  2706  	i := len(dAtA)
  2707  	_ = i
  2708  	var l int
  2709  	_ = l
  2710  	if m.unknownFields != nil {
  2711  		i -= len(m.unknownFields)
  2712  		copy(dAtA[i:], m.unknownFields)
  2713  	}
  2714  	if m.IncludeNonServingShards {
  2715  		i--
  2716  		if m.IncludeNonServingShards {
  2717  			dAtA[i] = 1
  2718  		} else {
  2719  			dAtA[i] = 0
  2720  		}
  2721  		i--
  2722  		dAtA[i] = 0x10
  2723  	}
  2724  	if m.AggregateSizes {
  2725  		i--
  2726  		if m.AggregateSizes {
  2727  			dAtA[i] = 1
  2728  		} else {
  2729  			dAtA[i] = 0
  2730  		}
  2731  		i--
  2732  		dAtA[i] = 0x8
  2733  	}
  2734  	return len(dAtA) - i, nil
  2735  }
  2736  
  2737  func (m *GetTabletRequest) MarshalVT() (dAtA []byte, err error) {
  2738  	if m == nil {
  2739  		return nil, nil
  2740  	}
  2741  	size := m.SizeVT()
  2742  	dAtA = make([]byte, size)
  2743  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2744  	if err != nil {
  2745  		return nil, err
  2746  	}
  2747  	return dAtA[:n], nil
  2748  }
  2749  
  2750  func (m *GetTabletRequest) MarshalToVT(dAtA []byte) (int, error) {
  2751  	size := m.SizeVT()
  2752  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2753  }
  2754  
  2755  func (m *GetTabletRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2756  	if m == nil {
  2757  		return 0, nil
  2758  	}
  2759  	i := len(dAtA)
  2760  	_ = i
  2761  	var l int
  2762  	_ = l
  2763  	if m.unknownFields != nil {
  2764  		i -= len(m.unknownFields)
  2765  		copy(dAtA[i:], m.unknownFields)
  2766  	}
  2767  	if len(m.ClusterIds) > 0 {
  2768  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2769  			i -= len(m.ClusterIds[iNdEx])
  2770  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2771  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2772  			i--
  2773  			dAtA[i] = 0x12
  2774  		}
  2775  	}
  2776  	if m.Alias != nil {
  2777  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  2778  		if err != nil {
  2779  			return 0, err
  2780  		}
  2781  		i -= size
  2782  		i = encodeVarint(dAtA, i, uint64(size))
  2783  		i--
  2784  		dAtA[i] = 0xa
  2785  	}
  2786  	return len(dAtA) - i, nil
  2787  }
  2788  
  2789  func (m *GetTabletsRequest) MarshalVT() (dAtA []byte, err error) {
  2790  	if m == nil {
  2791  		return nil, nil
  2792  	}
  2793  	size := m.SizeVT()
  2794  	dAtA = make([]byte, size)
  2795  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2796  	if err != nil {
  2797  		return nil, err
  2798  	}
  2799  	return dAtA[:n], nil
  2800  }
  2801  
  2802  func (m *GetTabletsRequest) MarshalToVT(dAtA []byte) (int, error) {
  2803  	size := m.SizeVT()
  2804  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2805  }
  2806  
  2807  func (m *GetTabletsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2808  	if m == nil {
  2809  		return 0, nil
  2810  	}
  2811  	i := len(dAtA)
  2812  	_ = i
  2813  	var l int
  2814  	_ = l
  2815  	if m.unknownFields != nil {
  2816  		i -= len(m.unknownFields)
  2817  		copy(dAtA[i:], m.unknownFields)
  2818  	}
  2819  	if len(m.ClusterIds) > 0 {
  2820  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  2821  			i -= len(m.ClusterIds[iNdEx])
  2822  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  2823  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  2824  			i--
  2825  			dAtA[i] = 0xa
  2826  		}
  2827  	}
  2828  	return len(dAtA) - i, nil
  2829  }
  2830  
  2831  func (m *GetTabletsResponse) MarshalVT() (dAtA []byte, err error) {
  2832  	if m == nil {
  2833  		return nil, nil
  2834  	}
  2835  	size := m.SizeVT()
  2836  	dAtA = make([]byte, size)
  2837  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2838  	if err != nil {
  2839  		return nil, err
  2840  	}
  2841  	return dAtA[:n], nil
  2842  }
  2843  
  2844  func (m *GetTabletsResponse) MarshalToVT(dAtA []byte) (int, error) {
  2845  	size := m.SizeVT()
  2846  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2847  }
  2848  
  2849  func (m *GetTabletsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2850  	if m == nil {
  2851  		return 0, nil
  2852  	}
  2853  	i := len(dAtA)
  2854  	_ = i
  2855  	var l int
  2856  	_ = l
  2857  	if m.unknownFields != nil {
  2858  		i -= len(m.unknownFields)
  2859  		copy(dAtA[i:], m.unknownFields)
  2860  	}
  2861  	if len(m.Tablets) > 0 {
  2862  		for iNdEx := len(m.Tablets) - 1; iNdEx >= 0; iNdEx-- {
  2863  			size, err := m.Tablets[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  2864  			if err != nil {
  2865  				return 0, err
  2866  			}
  2867  			i -= size
  2868  			i = encodeVarint(dAtA, i, uint64(size))
  2869  			i--
  2870  			dAtA[i] = 0xa
  2871  		}
  2872  	}
  2873  	return len(dAtA) - i, nil
  2874  }
  2875  
  2876  func (m *GetTopologyPathRequest) MarshalVT() (dAtA []byte, err error) {
  2877  	if m == nil {
  2878  		return nil, nil
  2879  	}
  2880  	size := m.SizeVT()
  2881  	dAtA = make([]byte, size)
  2882  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2883  	if err != nil {
  2884  		return nil, err
  2885  	}
  2886  	return dAtA[:n], nil
  2887  }
  2888  
  2889  func (m *GetTopologyPathRequest) MarshalToVT(dAtA []byte) (int, error) {
  2890  	size := m.SizeVT()
  2891  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2892  }
  2893  
  2894  func (m *GetTopologyPathRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2895  	if m == nil {
  2896  		return 0, nil
  2897  	}
  2898  	i := len(dAtA)
  2899  	_ = i
  2900  	var l int
  2901  	_ = l
  2902  	if m.unknownFields != nil {
  2903  		i -= len(m.unknownFields)
  2904  		copy(dAtA[i:], m.unknownFields)
  2905  	}
  2906  	if len(m.Path) > 0 {
  2907  		i -= len(m.Path)
  2908  		copy(dAtA[i:], m.Path)
  2909  		i = encodeVarint(dAtA, i, uint64(len(m.Path)))
  2910  		i--
  2911  		dAtA[i] = 0x12
  2912  	}
  2913  	if len(m.ClusterId) > 0 {
  2914  		i -= len(m.ClusterId)
  2915  		copy(dAtA[i:], m.ClusterId)
  2916  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  2917  		i--
  2918  		dAtA[i] = 0xa
  2919  	}
  2920  	return len(dAtA) - i, nil
  2921  }
  2922  
  2923  func (m *GetVSchemaRequest) MarshalVT() (dAtA []byte, err error) {
  2924  	if m == nil {
  2925  		return nil, nil
  2926  	}
  2927  	size := m.SizeVT()
  2928  	dAtA = make([]byte, size)
  2929  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2930  	if err != nil {
  2931  		return nil, err
  2932  	}
  2933  	return dAtA[:n], nil
  2934  }
  2935  
  2936  func (m *GetVSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  2937  	size := m.SizeVT()
  2938  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2939  }
  2940  
  2941  func (m *GetVSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2942  	if m == nil {
  2943  		return 0, nil
  2944  	}
  2945  	i := len(dAtA)
  2946  	_ = i
  2947  	var l int
  2948  	_ = l
  2949  	if m.unknownFields != nil {
  2950  		i -= len(m.unknownFields)
  2951  		copy(dAtA[i:], m.unknownFields)
  2952  	}
  2953  	if len(m.Keyspace) > 0 {
  2954  		i -= len(m.Keyspace)
  2955  		copy(dAtA[i:], m.Keyspace)
  2956  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  2957  		i--
  2958  		dAtA[i] = 0x12
  2959  	}
  2960  	if len(m.ClusterId) > 0 {
  2961  		i -= len(m.ClusterId)
  2962  		copy(dAtA[i:], m.ClusterId)
  2963  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  2964  		i--
  2965  		dAtA[i] = 0xa
  2966  	}
  2967  	return len(dAtA) - i, nil
  2968  }
  2969  
  2970  func (m *GetVSchemasRequest) MarshalVT() (dAtA []byte, err error) {
  2971  	if m == nil {
  2972  		return nil, nil
  2973  	}
  2974  	size := m.SizeVT()
  2975  	dAtA = make([]byte, size)
  2976  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2977  	if err != nil {
  2978  		return nil, err
  2979  	}
  2980  	return dAtA[:n], nil
  2981  }
  2982  
  2983  func (m *GetVSchemasRequest) MarshalToVT(dAtA []byte) (int, error) {
  2984  	size := m.SizeVT()
  2985  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2986  }
  2987  
  2988  func (m *GetVSchemasRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2989  	if m == nil {
  2990  		return 0, nil
  2991  	}
  2992  	i := len(dAtA)
  2993  	_ = i
  2994  	var l int
  2995  	_ = l
  2996  	if m.unknownFields != nil {
  2997  		i -= len(m.unknownFields)
  2998  		copy(dAtA[i:], m.unknownFields)
  2999  	}
  3000  	if len(m.ClusterIds) > 0 {
  3001  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  3002  			i -= len(m.ClusterIds[iNdEx])
  3003  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  3004  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  3005  			i--
  3006  			dAtA[i] = 0xa
  3007  		}
  3008  	}
  3009  	return len(dAtA) - i, nil
  3010  }
  3011  
  3012  func (m *GetVSchemasResponse) MarshalVT() (dAtA []byte, err error) {
  3013  	if m == nil {
  3014  		return nil, nil
  3015  	}
  3016  	size := m.SizeVT()
  3017  	dAtA = make([]byte, size)
  3018  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3019  	if err != nil {
  3020  		return nil, err
  3021  	}
  3022  	return dAtA[:n], nil
  3023  }
  3024  
  3025  func (m *GetVSchemasResponse) MarshalToVT(dAtA []byte) (int, error) {
  3026  	size := m.SizeVT()
  3027  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3028  }
  3029  
  3030  func (m *GetVSchemasResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3031  	if m == nil {
  3032  		return 0, nil
  3033  	}
  3034  	i := len(dAtA)
  3035  	_ = i
  3036  	var l int
  3037  	_ = l
  3038  	if m.unknownFields != nil {
  3039  		i -= len(m.unknownFields)
  3040  		copy(dAtA[i:], m.unknownFields)
  3041  	}
  3042  	if len(m.VSchemas) > 0 {
  3043  		for iNdEx := len(m.VSchemas) - 1; iNdEx >= 0; iNdEx-- {
  3044  			size, err := m.VSchemas[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  3045  			if err != nil {
  3046  				return 0, err
  3047  			}
  3048  			i -= size
  3049  			i = encodeVarint(dAtA, i, uint64(size))
  3050  			i--
  3051  			dAtA[i] = 0xa
  3052  		}
  3053  	}
  3054  	return len(dAtA) - i, nil
  3055  }
  3056  
  3057  func (m *GetVtctldsRequest) MarshalVT() (dAtA []byte, err error) {
  3058  	if m == nil {
  3059  		return nil, nil
  3060  	}
  3061  	size := m.SizeVT()
  3062  	dAtA = make([]byte, size)
  3063  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3064  	if err != nil {
  3065  		return nil, err
  3066  	}
  3067  	return dAtA[:n], nil
  3068  }
  3069  
  3070  func (m *GetVtctldsRequest) MarshalToVT(dAtA []byte) (int, error) {
  3071  	size := m.SizeVT()
  3072  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3073  }
  3074  
  3075  func (m *GetVtctldsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3076  	if m == nil {
  3077  		return 0, nil
  3078  	}
  3079  	i := len(dAtA)
  3080  	_ = i
  3081  	var l int
  3082  	_ = l
  3083  	if m.unknownFields != nil {
  3084  		i -= len(m.unknownFields)
  3085  		copy(dAtA[i:], m.unknownFields)
  3086  	}
  3087  	if len(m.ClusterIds) > 0 {
  3088  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  3089  			i -= len(m.ClusterIds[iNdEx])
  3090  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  3091  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  3092  			i--
  3093  			dAtA[i] = 0xa
  3094  		}
  3095  	}
  3096  	return len(dAtA) - i, nil
  3097  }
  3098  
  3099  func (m *GetVtctldsResponse) 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 *GetVtctldsResponse) MarshalToVT(dAtA []byte) (int, error) {
  3113  	size := m.SizeVT()
  3114  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3115  }
  3116  
  3117  func (m *GetVtctldsResponse) 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.Vtctlds) > 0 {
  3130  		for iNdEx := len(m.Vtctlds) - 1; iNdEx >= 0; iNdEx-- {
  3131  			size, err := m.Vtctlds[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  3132  			if err != nil {
  3133  				return 0, err
  3134  			}
  3135  			i -= size
  3136  			i = encodeVarint(dAtA, i, uint64(size))
  3137  			i--
  3138  			dAtA[i] = 0xa
  3139  		}
  3140  	}
  3141  	return len(dAtA) - i, nil
  3142  }
  3143  
  3144  func (m *GetWorkflowRequest) MarshalVT() (dAtA []byte, err error) {
  3145  	if m == nil {
  3146  		return nil, nil
  3147  	}
  3148  	size := m.SizeVT()
  3149  	dAtA = make([]byte, size)
  3150  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3151  	if err != nil {
  3152  		return nil, err
  3153  	}
  3154  	return dAtA[:n], nil
  3155  }
  3156  
  3157  func (m *GetWorkflowRequest) MarshalToVT(dAtA []byte) (int, error) {
  3158  	size := m.SizeVT()
  3159  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3160  }
  3161  
  3162  func (m *GetWorkflowRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3163  	if m == nil {
  3164  		return 0, nil
  3165  	}
  3166  	i := len(dAtA)
  3167  	_ = i
  3168  	var l int
  3169  	_ = l
  3170  	if m.unknownFields != nil {
  3171  		i -= len(m.unknownFields)
  3172  		copy(dAtA[i:], m.unknownFields)
  3173  	}
  3174  	if m.ActiveOnly {
  3175  		i--
  3176  		if m.ActiveOnly {
  3177  			dAtA[i] = 1
  3178  		} else {
  3179  			dAtA[i] = 0
  3180  		}
  3181  		i--
  3182  		dAtA[i] = 0x20
  3183  	}
  3184  	if len(m.Name) > 0 {
  3185  		i -= len(m.Name)
  3186  		copy(dAtA[i:], m.Name)
  3187  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
  3188  		i--
  3189  		dAtA[i] = 0x1a
  3190  	}
  3191  	if len(m.Keyspace) > 0 {
  3192  		i -= len(m.Keyspace)
  3193  		copy(dAtA[i:], m.Keyspace)
  3194  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  3195  		i--
  3196  		dAtA[i] = 0x12
  3197  	}
  3198  	if len(m.ClusterId) > 0 {
  3199  		i -= len(m.ClusterId)
  3200  		copy(dAtA[i:], m.ClusterId)
  3201  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  3202  		i--
  3203  		dAtA[i] = 0xa
  3204  	}
  3205  	return len(dAtA) - i, nil
  3206  }
  3207  
  3208  func (m *GetWorkflowsRequest) MarshalVT() (dAtA []byte, err error) {
  3209  	if m == nil {
  3210  		return nil, nil
  3211  	}
  3212  	size := m.SizeVT()
  3213  	dAtA = make([]byte, size)
  3214  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3215  	if err != nil {
  3216  		return nil, err
  3217  	}
  3218  	return dAtA[:n], nil
  3219  }
  3220  
  3221  func (m *GetWorkflowsRequest) MarshalToVT(dAtA []byte) (int, error) {
  3222  	size := m.SizeVT()
  3223  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3224  }
  3225  
  3226  func (m *GetWorkflowsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3227  	if m == nil {
  3228  		return 0, nil
  3229  	}
  3230  	i := len(dAtA)
  3231  	_ = i
  3232  	var l int
  3233  	_ = l
  3234  	if m.unknownFields != nil {
  3235  		i -= len(m.unknownFields)
  3236  		copy(dAtA[i:], m.unknownFields)
  3237  	}
  3238  	if len(m.IgnoreKeyspaces) > 0 {
  3239  		for iNdEx := len(m.IgnoreKeyspaces) - 1; iNdEx >= 0; iNdEx-- {
  3240  			i -= len(m.IgnoreKeyspaces[iNdEx])
  3241  			copy(dAtA[i:], m.IgnoreKeyspaces[iNdEx])
  3242  			i = encodeVarint(dAtA, i, uint64(len(m.IgnoreKeyspaces[iNdEx])))
  3243  			i--
  3244  			dAtA[i] = 0x22
  3245  		}
  3246  	}
  3247  	if len(m.Keyspaces) > 0 {
  3248  		for iNdEx := len(m.Keyspaces) - 1; iNdEx >= 0; iNdEx-- {
  3249  			i -= len(m.Keyspaces[iNdEx])
  3250  			copy(dAtA[i:], m.Keyspaces[iNdEx])
  3251  			i = encodeVarint(dAtA, i, uint64(len(m.Keyspaces[iNdEx])))
  3252  			i--
  3253  			dAtA[i] = 0x1a
  3254  		}
  3255  	}
  3256  	if m.ActiveOnly {
  3257  		i--
  3258  		if m.ActiveOnly {
  3259  			dAtA[i] = 1
  3260  		} else {
  3261  			dAtA[i] = 0
  3262  		}
  3263  		i--
  3264  		dAtA[i] = 0x10
  3265  	}
  3266  	if len(m.ClusterIds) > 0 {
  3267  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  3268  			i -= len(m.ClusterIds[iNdEx])
  3269  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  3270  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  3271  			i--
  3272  			dAtA[i] = 0xa
  3273  		}
  3274  	}
  3275  	return len(dAtA) - i, nil
  3276  }
  3277  
  3278  func (m *GetWorkflowsResponse) MarshalVT() (dAtA []byte, err error) {
  3279  	if m == nil {
  3280  		return nil, nil
  3281  	}
  3282  	size := m.SizeVT()
  3283  	dAtA = make([]byte, size)
  3284  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3285  	if err != nil {
  3286  		return nil, err
  3287  	}
  3288  	return dAtA[:n], nil
  3289  }
  3290  
  3291  func (m *GetWorkflowsResponse) MarshalToVT(dAtA []byte) (int, error) {
  3292  	size := m.SizeVT()
  3293  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3294  }
  3295  
  3296  func (m *GetWorkflowsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3297  	if m == nil {
  3298  		return 0, nil
  3299  	}
  3300  	i := len(dAtA)
  3301  	_ = i
  3302  	var l int
  3303  	_ = l
  3304  	if m.unknownFields != nil {
  3305  		i -= len(m.unknownFields)
  3306  		copy(dAtA[i:], m.unknownFields)
  3307  	}
  3308  	if len(m.WorkflowsByCluster) > 0 {
  3309  		for k := range m.WorkflowsByCluster {
  3310  			v := m.WorkflowsByCluster[k]
  3311  			baseI := i
  3312  			size, err := v.MarshalToSizedBufferVT(dAtA[:i])
  3313  			if err != nil {
  3314  				return 0, err
  3315  			}
  3316  			i -= size
  3317  			i = encodeVarint(dAtA, i, uint64(size))
  3318  			i--
  3319  			dAtA[i] = 0x12
  3320  			i -= len(k)
  3321  			copy(dAtA[i:], k)
  3322  			i = encodeVarint(dAtA, i, uint64(len(k)))
  3323  			i--
  3324  			dAtA[i] = 0xa
  3325  			i = encodeVarint(dAtA, i, uint64(baseI-i))
  3326  			i--
  3327  			dAtA[i] = 0xa
  3328  		}
  3329  	}
  3330  	return len(dAtA) - i, nil
  3331  }
  3332  
  3333  func (m *PingTabletRequest) MarshalVT() (dAtA []byte, err error) {
  3334  	if m == nil {
  3335  		return nil, nil
  3336  	}
  3337  	size := m.SizeVT()
  3338  	dAtA = make([]byte, size)
  3339  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3340  	if err != nil {
  3341  		return nil, err
  3342  	}
  3343  	return dAtA[:n], nil
  3344  }
  3345  
  3346  func (m *PingTabletRequest) MarshalToVT(dAtA []byte) (int, error) {
  3347  	size := m.SizeVT()
  3348  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3349  }
  3350  
  3351  func (m *PingTabletRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3352  	if m == nil {
  3353  		return 0, nil
  3354  	}
  3355  	i := len(dAtA)
  3356  	_ = i
  3357  	var l int
  3358  	_ = l
  3359  	if m.unknownFields != nil {
  3360  		i -= len(m.unknownFields)
  3361  		copy(dAtA[i:], m.unknownFields)
  3362  	}
  3363  	if len(m.ClusterIds) > 0 {
  3364  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  3365  			i -= len(m.ClusterIds[iNdEx])
  3366  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  3367  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  3368  			i--
  3369  			dAtA[i] = 0x12
  3370  		}
  3371  	}
  3372  	if m.Alias != nil {
  3373  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  3374  		if err != nil {
  3375  			return 0, err
  3376  		}
  3377  		i -= size
  3378  		i = encodeVarint(dAtA, i, uint64(size))
  3379  		i--
  3380  		dAtA[i] = 0xa
  3381  	}
  3382  	return len(dAtA) - i, nil
  3383  }
  3384  
  3385  func (m *PingTabletResponse) MarshalVT() (dAtA []byte, err error) {
  3386  	if m == nil {
  3387  		return nil, nil
  3388  	}
  3389  	size := m.SizeVT()
  3390  	dAtA = make([]byte, size)
  3391  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3392  	if err != nil {
  3393  		return nil, err
  3394  	}
  3395  	return dAtA[:n], nil
  3396  }
  3397  
  3398  func (m *PingTabletResponse) MarshalToVT(dAtA []byte) (int, error) {
  3399  	size := m.SizeVT()
  3400  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3401  }
  3402  
  3403  func (m *PingTabletResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3404  	if m == nil {
  3405  		return 0, nil
  3406  	}
  3407  	i := len(dAtA)
  3408  	_ = i
  3409  	var l int
  3410  	_ = l
  3411  	if m.unknownFields != nil {
  3412  		i -= len(m.unknownFields)
  3413  		copy(dAtA[i:], m.unknownFields)
  3414  	}
  3415  	if m.Cluster != nil {
  3416  		size, err := m.Cluster.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 len(m.Status) > 0 {
  3426  		i -= len(m.Status)
  3427  		copy(dAtA[i:], m.Status)
  3428  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  3429  		i--
  3430  		dAtA[i] = 0xa
  3431  	}
  3432  	return len(dAtA) - i, nil
  3433  }
  3434  
  3435  func (m *PlannedFailoverShardRequest) MarshalVT() (dAtA []byte, err error) {
  3436  	if m == nil {
  3437  		return nil, nil
  3438  	}
  3439  	size := m.SizeVT()
  3440  	dAtA = make([]byte, size)
  3441  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3442  	if err != nil {
  3443  		return nil, err
  3444  	}
  3445  	return dAtA[:n], nil
  3446  }
  3447  
  3448  func (m *PlannedFailoverShardRequest) MarshalToVT(dAtA []byte) (int, error) {
  3449  	size := m.SizeVT()
  3450  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3451  }
  3452  
  3453  func (m *PlannedFailoverShardRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3454  	if m == nil {
  3455  		return 0, nil
  3456  	}
  3457  	i := len(dAtA)
  3458  	_ = i
  3459  	var l int
  3460  	_ = l
  3461  	if m.unknownFields != nil {
  3462  		i -= len(m.unknownFields)
  3463  		copy(dAtA[i:], m.unknownFields)
  3464  	}
  3465  	if m.Options != nil {
  3466  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  3467  		if err != nil {
  3468  			return 0, err
  3469  		}
  3470  		i -= size
  3471  		i = encodeVarint(dAtA, i, uint64(size))
  3472  		i--
  3473  		dAtA[i] = 0x12
  3474  	}
  3475  	if len(m.ClusterId) > 0 {
  3476  		i -= len(m.ClusterId)
  3477  		copy(dAtA[i:], m.ClusterId)
  3478  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  3479  		i--
  3480  		dAtA[i] = 0xa
  3481  	}
  3482  	return len(dAtA) - i, nil
  3483  }
  3484  
  3485  func (m *PlannedFailoverShardResponse) MarshalVT() (dAtA []byte, err error) {
  3486  	if m == nil {
  3487  		return nil, nil
  3488  	}
  3489  	size := m.SizeVT()
  3490  	dAtA = make([]byte, size)
  3491  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3492  	if err != nil {
  3493  		return nil, err
  3494  	}
  3495  	return dAtA[:n], nil
  3496  }
  3497  
  3498  func (m *PlannedFailoverShardResponse) MarshalToVT(dAtA []byte) (int, error) {
  3499  	size := m.SizeVT()
  3500  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3501  }
  3502  
  3503  func (m *PlannedFailoverShardResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3504  	if m == nil {
  3505  		return 0, nil
  3506  	}
  3507  	i := len(dAtA)
  3508  	_ = i
  3509  	var l int
  3510  	_ = l
  3511  	if m.unknownFields != nil {
  3512  		i -= len(m.unknownFields)
  3513  		copy(dAtA[i:], m.unknownFields)
  3514  	}
  3515  	if len(m.Events) > 0 {
  3516  		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
  3517  			size, err := m.Events[iNdEx].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] = 0x2a
  3525  		}
  3526  	}
  3527  	if m.PromotedPrimary != nil {
  3528  		size, err := m.PromotedPrimary.MarshalToSizedBufferVT(dAtA[:i])
  3529  		if err != nil {
  3530  			return 0, err
  3531  		}
  3532  		i -= size
  3533  		i = encodeVarint(dAtA, i, uint64(size))
  3534  		i--
  3535  		dAtA[i] = 0x22
  3536  	}
  3537  	if len(m.Shard) > 0 {
  3538  		i -= len(m.Shard)
  3539  		copy(dAtA[i:], m.Shard)
  3540  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  3541  		i--
  3542  		dAtA[i] = 0x1a
  3543  	}
  3544  	if len(m.Keyspace) > 0 {
  3545  		i -= len(m.Keyspace)
  3546  		copy(dAtA[i:], m.Keyspace)
  3547  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  3548  		i--
  3549  		dAtA[i] = 0x12
  3550  	}
  3551  	if m.Cluster != nil {
  3552  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  3553  		if err != nil {
  3554  			return 0, err
  3555  		}
  3556  		i -= size
  3557  		i = encodeVarint(dAtA, i, uint64(size))
  3558  		i--
  3559  		dAtA[i] = 0xa
  3560  	}
  3561  	return len(dAtA) - i, nil
  3562  }
  3563  
  3564  func (m *RebuildKeyspaceGraphRequest) MarshalVT() (dAtA []byte, err error) {
  3565  	if m == nil {
  3566  		return nil, nil
  3567  	}
  3568  	size := m.SizeVT()
  3569  	dAtA = make([]byte, size)
  3570  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3571  	if err != nil {
  3572  		return nil, err
  3573  	}
  3574  	return dAtA[:n], nil
  3575  }
  3576  
  3577  func (m *RebuildKeyspaceGraphRequest) MarshalToVT(dAtA []byte) (int, error) {
  3578  	size := m.SizeVT()
  3579  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3580  }
  3581  
  3582  func (m *RebuildKeyspaceGraphRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3583  	if m == nil {
  3584  		return 0, nil
  3585  	}
  3586  	i := len(dAtA)
  3587  	_ = i
  3588  	var l int
  3589  	_ = l
  3590  	if m.unknownFields != nil {
  3591  		i -= len(m.unknownFields)
  3592  		copy(dAtA[i:], m.unknownFields)
  3593  	}
  3594  	if m.AllowPartial {
  3595  		i--
  3596  		if m.AllowPartial {
  3597  			dAtA[i] = 1
  3598  		} else {
  3599  			dAtA[i] = 0
  3600  		}
  3601  		i--
  3602  		dAtA[i] = 0x20
  3603  	}
  3604  	if len(m.Cells) > 0 {
  3605  		for iNdEx := len(m.Cells) - 1; iNdEx >= 0; iNdEx-- {
  3606  			i -= len(m.Cells[iNdEx])
  3607  			copy(dAtA[i:], m.Cells[iNdEx])
  3608  			i = encodeVarint(dAtA, i, uint64(len(m.Cells[iNdEx])))
  3609  			i--
  3610  			dAtA[i] = 0x1a
  3611  		}
  3612  	}
  3613  	if len(m.Keyspace) > 0 {
  3614  		i -= len(m.Keyspace)
  3615  		copy(dAtA[i:], m.Keyspace)
  3616  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  3617  		i--
  3618  		dAtA[i] = 0x12
  3619  	}
  3620  	if len(m.ClusterId) > 0 {
  3621  		i -= len(m.ClusterId)
  3622  		copy(dAtA[i:], m.ClusterId)
  3623  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  3624  		i--
  3625  		dAtA[i] = 0xa
  3626  	}
  3627  	return len(dAtA) - i, nil
  3628  }
  3629  
  3630  func (m *RebuildKeyspaceGraphResponse) MarshalVT() (dAtA []byte, err error) {
  3631  	if m == nil {
  3632  		return nil, nil
  3633  	}
  3634  	size := m.SizeVT()
  3635  	dAtA = make([]byte, size)
  3636  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3637  	if err != nil {
  3638  		return nil, err
  3639  	}
  3640  	return dAtA[:n], nil
  3641  }
  3642  
  3643  func (m *RebuildKeyspaceGraphResponse) MarshalToVT(dAtA []byte) (int, error) {
  3644  	size := m.SizeVT()
  3645  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3646  }
  3647  
  3648  func (m *RebuildKeyspaceGraphResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3649  	if m == nil {
  3650  		return 0, nil
  3651  	}
  3652  	i := len(dAtA)
  3653  	_ = i
  3654  	var l int
  3655  	_ = l
  3656  	if m.unknownFields != nil {
  3657  		i -= len(m.unknownFields)
  3658  		copy(dAtA[i:], m.unknownFields)
  3659  	}
  3660  	if len(m.Status) > 0 {
  3661  		i -= len(m.Status)
  3662  		copy(dAtA[i:], m.Status)
  3663  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  3664  		i--
  3665  		dAtA[i] = 0xa
  3666  	}
  3667  	return len(dAtA) - i, nil
  3668  }
  3669  
  3670  func (m *RefreshStateRequest) MarshalVT() (dAtA []byte, err error) {
  3671  	if m == nil {
  3672  		return nil, nil
  3673  	}
  3674  	size := m.SizeVT()
  3675  	dAtA = make([]byte, size)
  3676  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3677  	if err != nil {
  3678  		return nil, err
  3679  	}
  3680  	return dAtA[:n], nil
  3681  }
  3682  
  3683  func (m *RefreshStateRequest) MarshalToVT(dAtA []byte) (int, error) {
  3684  	size := m.SizeVT()
  3685  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3686  }
  3687  
  3688  func (m *RefreshStateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3689  	if m == nil {
  3690  		return 0, nil
  3691  	}
  3692  	i := len(dAtA)
  3693  	_ = i
  3694  	var l int
  3695  	_ = l
  3696  	if m.unknownFields != nil {
  3697  		i -= len(m.unknownFields)
  3698  		copy(dAtA[i:], m.unknownFields)
  3699  	}
  3700  	if len(m.ClusterIds) > 0 {
  3701  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  3702  			i -= len(m.ClusterIds[iNdEx])
  3703  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  3704  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  3705  			i--
  3706  			dAtA[i] = 0x12
  3707  		}
  3708  	}
  3709  	if m.Alias != nil {
  3710  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  3711  		if err != nil {
  3712  			return 0, err
  3713  		}
  3714  		i -= size
  3715  		i = encodeVarint(dAtA, i, uint64(size))
  3716  		i--
  3717  		dAtA[i] = 0xa
  3718  	}
  3719  	return len(dAtA) - i, nil
  3720  }
  3721  
  3722  func (m *RefreshStateResponse) MarshalVT() (dAtA []byte, err error) {
  3723  	if m == nil {
  3724  		return nil, nil
  3725  	}
  3726  	size := m.SizeVT()
  3727  	dAtA = make([]byte, size)
  3728  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3729  	if err != nil {
  3730  		return nil, err
  3731  	}
  3732  	return dAtA[:n], nil
  3733  }
  3734  
  3735  func (m *RefreshStateResponse) MarshalToVT(dAtA []byte) (int, error) {
  3736  	size := m.SizeVT()
  3737  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3738  }
  3739  
  3740  func (m *RefreshStateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3741  	if m == nil {
  3742  		return 0, nil
  3743  	}
  3744  	i := len(dAtA)
  3745  	_ = i
  3746  	var l int
  3747  	_ = l
  3748  	if m.unknownFields != nil {
  3749  		i -= len(m.unknownFields)
  3750  		copy(dAtA[i:], m.unknownFields)
  3751  	}
  3752  	if m.Cluster != nil {
  3753  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  3754  		if err != nil {
  3755  			return 0, err
  3756  		}
  3757  		i -= size
  3758  		i = encodeVarint(dAtA, i, uint64(size))
  3759  		i--
  3760  		dAtA[i] = 0x12
  3761  	}
  3762  	if len(m.Status) > 0 {
  3763  		i -= len(m.Status)
  3764  		copy(dAtA[i:], m.Status)
  3765  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  3766  		i--
  3767  		dAtA[i] = 0xa
  3768  	}
  3769  	return len(dAtA) - i, nil
  3770  }
  3771  
  3772  func (m *ReloadSchemasRequest) MarshalVT() (dAtA []byte, err error) {
  3773  	if m == nil {
  3774  		return nil, nil
  3775  	}
  3776  	size := m.SizeVT()
  3777  	dAtA = make([]byte, size)
  3778  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3779  	if err != nil {
  3780  		return nil, err
  3781  	}
  3782  	return dAtA[:n], nil
  3783  }
  3784  
  3785  func (m *ReloadSchemasRequest) MarshalToVT(dAtA []byte) (int, error) {
  3786  	size := m.SizeVT()
  3787  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3788  }
  3789  
  3790  func (m *ReloadSchemasRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3791  	if m == nil {
  3792  		return 0, nil
  3793  	}
  3794  	i := len(dAtA)
  3795  	_ = i
  3796  	var l int
  3797  	_ = l
  3798  	if m.unknownFields != nil {
  3799  		i -= len(m.unknownFields)
  3800  		copy(dAtA[i:], m.unknownFields)
  3801  	}
  3802  	if m.IncludePrimary {
  3803  		i--
  3804  		if m.IncludePrimary {
  3805  			dAtA[i] = 1
  3806  		} else {
  3807  			dAtA[i] = 0
  3808  		}
  3809  		i--
  3810  		dAtA[i] = 0x38
  3811  	}
  3812  	if len(m.WaitPosition) > 0 {
  3813  		i -= len(m.WaitPosition)
  3814  		copy(dAtA[i:], m.WaitPosition)
  3815  		i = encodeVarint(dAtA, i, uint64(len(m.WaitPosition)))
  3816  		i--
  3817  		dAtA[i] = 0x32
  3818  	}
  3819  	if m.Concurrency != 0 {
  3820  		i = encodeVarint(dAtA, i, uint64(m.Concurrency))
  3821  		i--
  3822  		dAtA[i] = 0x28
  3823  	}
  3824  	if len(m.ClusterIds) > 0 {
  3825  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  3826  			i -= len(m.ClusterIds[iNdEx])
  3827  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  3828  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  3829  			i--
  3830  			dAtA[i] = 0x22
  3831  		}
  3832  	}
  3833  	if len(m.Tablets) > 0 {
  3834  		for iNdEx := len(m.Tablets) - 1; iNdEx >= 0; iNdEx-- {
  3835  			size, err := m.Tablets[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  3836  			if err != nil {
  3837  				return 0, err
  3838  			}
  3839  			i -= size
  3840  			i = encodeVarint(dAtA, i, uint64(size))
  3841  			i--
  3842  			dAtA[i] = 0x1a
  3843  		}
  3844  	}
  3845  	if len(m.KeyspaceShards) > 0 {
  3846  		for iNdEx := len(m.KeyspaceShards) - 1; iNdEx >= 0; iNdEx-- {
  3847  			i -= len(m.KeyspaceShards[iNdEx])
  3848  			copy(dAtA[i:], m.KeyspaceShards[iNdEx])
  3849  			i = encodeVarint(dAtA, i, uint64(len(m.KeyspaceShards[iNdEx])))
  3850  			i--
  3851  			dAtA[i] = 0x12
  3852  		}
  3853  	}
  3854  	if len(m.Keyspaces) > 0 {
  3855  		for iNdEx := len(m.Keyspaces) - 1; iNdEx >= 0; iNdEx-- {
  3856  			i -= len(m.Keyspaces[iNdEx])
  3857  			copy(dAtA[i:], m.Keyspaces[iNdEx])
  3858  			i = encodeVarint(dAtA, i, uint64(len(m.Keyspaces[iNdEx])))
  3859  			i--
  3860  			dAtA[i] = 0xa
  3861  		}
  3862  	}
  3863  	return len(dAtA) - i, nil
  3864  }
  3865  
  3866  func (m *ReloadSchemasResponse_KeyspaceResult) MarshalVT() (dAtA []byte, err error) {
  3867  	if m == nil {
  3868  		return nil, nil
  3869  	}
  3870  	size := m.SizeVT()
  3871  	dAtA = make([]byte, size)
  3872  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3873  	if err != nil {
  3874  		return nil, err
  3875  	}
  3876  	return dAtA[:n], nil
  3877  }
  3878  
  3879  func (m *ReloadSchemasResponse_KeyspaceResult) MarshalToVT(dAtA []byte) (int, error) {
  3880  	size := m.SizeVT()
  3881  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3882  }
  3883  
  3884  func (m *ReloadSchemasResponse_KeyspaceResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3885  	if m == nil {
  3886  		return 0, nil
  3887  	}
  3888  	i := len(dAtA)
  3889  	_ = i
  3890  	var l int
  3891  	_ = l
  3892  	if m.unknownFields != nil {
  3893  		i -= len(m.unknownFields)
  3894  		copy(dAtA[i:], m.unknownFields)
  3895  	}
  3896  	if len(m.Events) > 0 {
  3897  		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
  3898  			size, err := m.Events[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  3899  			if err != nil {
  3900  				return 0, err
  3901  			}
  3902  			i -= size
  3903  			i = encodeVarint(dAtA, i, uint64(size))
  3904  			i--
  3905  			dAtA[i] = 0x12
  3906  		}
  3907  	}
  3908  	if m.Keyspace != nil {
  3909  		size, err := m.Keyspace.MarshalToSizedBufferVT(dAtA[:i])
  3910  		if err != nil {
  3911  			return 0, err
  3912  		}
  3913  		i -= size
  3914  		i = encodeVarint(dAtA, i, uint64(size))
  3915  		i--
  3916  		dAtA[i] = 0xa
  3917  	}
  3918  	return len(dAtA) - i, nil
  3919  }
  3920  
  3921  func (m *ReloadSchemasResponse_ShardResult) MarshalVT() (dAtA []byte, err error) {
  3922  	if m == nil {
  3923  		return nil, nil
  3924  	}
  3925  	size := m.SizeVT()
  3926  	dAtA = make([]byte, size)
  3927  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3928  	if err != nil {
  3929  		return nil, err
  3930  	}
  3931  	return dAtA[:n], nil
  3932  }
  3933  
  3934  func (m *ReloadSchemasResponse_ShardResult) MarshalToVT(dAtA []byte) (int, error) {
  3935  	size := m.SizeVT()
  3936  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3937  }
  3938  
  3939  func (m *ReloadSchemasResponse_ShardResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3940  	if m == nil {
  3941  		return 0, nil
  3942  	}
  3943  	i := len(dAtA)
  3944  	_ = i
  3945  	var l int
  3946  	_ = l
  3947  	if m.unknownFields != nil {
  3948  		i -= len(m.unknownFields)
  3949  		copy(dAtA[i:], m.unknownFields)
  3950  	}
  3951  	if len(m.Events) > 0 {
  3952  		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
  3953  			size, err := m.Events[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  3954  			if err != nil {
  3955  				return 0, err
  3956  			}
  3957  			i -= size
  3958  			i = encodeVarint(dAtA, i, uint64(size))
  3959  			i--
  3960  			dAtA[i] = 0x12
  3961  		}
  3962  	}
  3963  	if m.Shard != nil {
  3964  		size, err := m.Shard.MarshalToSizedBufferVT(dAtA[:i])
  3965  		if err != nil {
  3966  			return 0, err
  3967  		}
  3968  		i -= size
  3969  		i = encodeVarint(dAtA, i, uint64(size))
  3970  		i--
  3971  		dAtA[i] = 0xa
  3972  	}
  3973  	return len(dAtA) - i, nil
  3974  }
  3975  
  3976  func (m *ReloadSchemasResponse_TabletResult) MarshalVT() (dAtA []byte, err error) {
  3977  	if m == nil {
  3978  		return nil, nil
  3979  	}
  3980  	size := m.SizeVT()
  3981  	dAtA = make([]byte, size)
  3982  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3983  	if err != nil {
  3984  		return nil, err
  3985  	}
  3986  	return dAtA[:n], nil
  3987  }
  3988  
  3989  func (m *ReloadSchemasResponse_TabletResult) MarshalToVT(dAtA []byte) (int, error) {
  3990  	size := m.SizeVT()
  3991  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3992  }
  3993  
  3994  func (m *ReloadSchemasResponse_TabletResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3995  	if m == nil {
  3996  		return 0, nil
  3997  	}
  3998  	i := len(dAtA)
  3999  	_ = i
  4000  	var l int
  4001  	_ = l
  4002  	if m.unknownFields != nil {
  4003  		i -= len(m.unknownFields)
  4004  		copy(dAtA[i:], m.unknownFields)
  4005  	}
  4006  	if len(m.Result) > 0 {
  4007  		i -= len(m.Result)
  4008  		copy(dAtA[i:], m.Result)
  4009  		i = encodeVarint(dAtA, i, uint64(len(m.Result)))
  4010  		i--
  4011  		dAtA[i] = 0x12
  4012  	}
  4013  	if m.Tablet != nil {
  4014  		size, err := m.Tablet.MarshalToSizedBufferVT(dAtA[:i])
  4015  		if err != nil {
  4016  			return 0, err
  4017  		}
  4018  		i -= size
  4019  		i = encodeVarint(dAtA, i, uint64(size))
  4020  		i--
  4021  		dAtA[i] = 0xa
  4022  	}
  4023  	return len(dAtA) - i, nil
  4024  }
  4025  
  4026  func (m *ReloadSchemasResponse) MarshalVT() (dAtA []byte, err error) {
  4027  	if m == nil {
  4028  		return nil, nil
  4029  	}
  4030  	size := m.SizeVT()
  4031  	dAtA = make([]byte, size)
  4032  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4033  	if err != nil {
  4034  		return nil, err
  4035  	}
  4036  	return dAtA[:n], nil
  4037  }
  4038  
  4039  func (m *ReloadSchemasResponse) MarshalToVT(dAtA []byte) (int, error) {
  4040  	size := m.SizeVT()
  4041  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4042  }
  4043  
  4044  func (m *ReloadSchemasResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4045  	if m == nil {
  4046  		return 0, nil
  4047  	}
  4048  	i := len(dAtA)
  4049  	_ = i
  4050  	var l int
  4051  	_ = l
  4052  	if m.unknownFields != nil {
  4053  		i -= len(m.unknownFields)
  4054  		copy(dAtA[i:], m.unknownFields)
  4055  	}
  4056  	if len(m.TabletResults) > 0 {
  4057  		for iNdEx := len(m.TabletResults) - 1; iNdEx >= 0; iNdEx-- {
  4058  			size, err := m.TabletResults[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  4059  			if err != nil {
  4060  				return 0, err
  4061  			}
  4062  			i -= size
  4063  			i = encodeVarint(dAtA, i, uint64(size))
  4064  			i--
  4065  			dAtA[i] = 0x1a
  4066  		}
  4067  	}
  4068  	if len(m.ShardResults) > 0 {
  4069  		for iNdEx := len(m.ShardResults) - 1; iNdEx >= 0; iNdEx-- {
  4070  			size, err := m.ShardResults[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  4071  			if err != nil {
  4072  				return 0, err
  4073  			}
  4074  			i -= size
  4075  			i = encodeVarint(dAtA, i, uint64(size))
  4076  			i--
  4077  			dAtA[i] = 0x12
  4078  		}
  4079  	}
  4080  	if len(m.KeyspaceResults) > 0 {
  4081  		for iNdEx := len(m.KeyspaceResults) - 1; iNdEx >= 0; iNdEx-- {
  4082  			size, err := m.KeyspaceResults[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  4083  			if err != nil {
  4084  				return 0, err
  4085  			}
  4086  			i -= size
  4087  			i = encodeVarint(dAtA, i, uint64(size))
  4088  			i--
  4089  			dAtA[i] = 0xa
  4090  		}
  4091  	}
  4092  	return len(dAtA) - i, nil
  4093  }
  4094  
  4095  func (m *ReloadSchemaShardRequest) MarshalVT() (dAtA []byte, err error) {
  4096  	if m == nil {
  4097  		return nil, nil
  4098  	}
  4099  	size := m.SizeVT()
  4100  	dAtA = make([]byte, size)
  4101  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4102  	if err != nil {
  4103  		return nil, err
  4104  	}
  4105  	return dAtA[:n], nil
  4106  }
  4107  
  4108  func (m *ReloadSchemaShardRequest) MarshalToVT(dAtA []byte) (int, error) {
  4109  	size := m.SizeVT()
  4110  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4111  }
  4112  
  4113  func (m *ReloadSchemaShardRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4114  	if m == nil {
  4115  		return 0, nil
  4116  	}
  4117  	i := len(dAtA)
  4118  	_ = i
  4119  	var l int
  4120  	_ = l
  4121  	if m.unknownFields != nil {
  4122  		i -= len(m.unknownFields)
  4123  		copy(dAtA[i:], m.unknownFields)
  4124  	}
  4125  	if m.Concurrency != 0 {
  4126  		i = encodeVarint(dAtA, i, uint64(m.Concurrency))
  4127  		i--
  4128  		dAtA[i] = 0x30
  4129  	}
  4130  	if m.IncludePrimary {
  4131  		i--
  4132  		if m.IncludePrimary {
  4133  			dAtA[i] = 1
  4134  		} else {
  4135  			dAtA[i] = 0
  4136  		}
  4137  		i--
  4138  		dAtA[i] = 0x28
  4139  	}
  4140  	if len(m.WaitPosition) > 0 {
  4141  		i -= len(m.WaitPosition)
  4142  		copy(dAtA[i:], m.WaitPosition)
  4143  		i = encodeVarint(dAtA, i, uint64(len(m.WaitPosition)))
  4144  		i--
  4145  		dAtA[i] = 0x22
  4146  	}
  4147  	if len(m.Shard) > 0 {
  4148  		i -= len(m.Shard)
  4149  		copy(dAtA[i:], m.Shard)
  4150  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  4151  		i--
  4152  		dAtA[i] = 0x1a
  4153  	}
  4154  	if len(m.Keyspace) > 0 {
  4155  		i -= len(m.Keyspace)
  4156  		copy(dAtA[i:], m.Keyspace)
  4157  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  4158  		i--
  4159  		dAtA[i] = 0x12
  4160  	}
  4161  	if len(m.ClusterId) > 0 {
  4162  		i -= len(m.ClusterId)
  4163  		copy(dAtA[i:], m.ClusterId)
  4164  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  4165  		i--
  4166  		dAtA[i] = 0xa
  4167  	}
  4168  	return len(dAtA) - i, nil
  4169  }
  4170  
  4171  func (m *ReloadSchemaShardResponse) MarshalVT() (dAtA []byte, err error) {
  4172  	if m == nil {
  4173  		return nil, nil
  4174  	}
  4175  	size := m.SizeVT()
  4176  	dAtA = make([]byte, size)
  4177  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4178  	if err != nil {
  4179  		return nil, err
  4180  	}
  4181  	return dAtA[:n], nil
  4182  }
  4183  
  4184  func (m *ReloadSchemaShardResponse) MarshalToVT(dAtA []byte) (int, error) {
  4185  	size := m.SizeVT()
  4186  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4187  }
  4188  
  4189  func (m *ReloadSchemaShardResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4190  	if m == nil {
  4191  		return 0, nil
  4192  	}
  4193  	i := len(dAtA)
  4194  	_ = i
  4195  	var l int
  4196  	_ = l
  4197  	if m.unknownFields != nil {
  4198  		i -= len(m.unknownFields)
  4199  		copy(dAtA[i:], m.unknownFields)
  4200  	}
  4201  	if len(m.Events) > 0 {
  4202  		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
  4203  			size, err := m.Events[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  4204  			if err != nil {
  4205  				return 0, err
  4206  			}
  4207  			i -= size
  4208  			i = encodeVarint(dAtA, i, uint64(size))
  4209  			i--
  4210  			dAtA[i] = 0xa
  4211  		}
  4212  	}
  4213  	return len(dAtA) - i, nil
  4214  }
  4215  
  4216  func (m *RefreshTabletReplicationSourceRequest) MarshalVT() (dAtA []byte, err error) {
  4217  	if m == nil {
  4218  		return nil, nil
  4219  	}
  4220  	size := m.SizeVT()
  4221  	dAtA = make([]byte, size)
  4222  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4223  	if err != nil {
  4224  		return nil, err
  4225  	}
  4226  	return dAtA[:n], nil
  4227  }
  4228  
  4229  func (m *RefreshTabletReplicationSourceRequest) MarshalToVT(dAtA []byte) (int, error) {
  4230  	size := m.SizeVT()
  4231  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4232  }
  4233  
  4234  func (m *RefreshTabletReplicationSourceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4235  	if m == nil {
  4236  		return 0, nil
  4237  	}
  4238  	i := len(dAtA)
  4239  	_ = i
  4240  	var l int
  4241  	_ = l
  4242  	if m.unknownFields != nil {
  4243  		i -= len(m.unknownFields)
  4244  		copy(dAtA[i:], m.unknownFields)
  4245  	}
  4246  	if len(m.ClusterIds) > 0 {
  4247  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4248  			i -= len(m.ClusterIds[iNdEx])
  4249  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4250  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4251  			i--
  4252  			dAtA[i] = 0x12
  4253  		}
  4254  	}
  4255  	if m.Alias != nil {
  4256  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4257  		if err != nil {
  4258  			return 0, err
  4259  		}
  4260  		i -= size
  4261  		i = encodeVarint(dAtA, i, uint64(size))
  4262  		i--
  4263  		dAtA[i] = 0xa
  4264  	}
  4265  	return len(dAtA) - i, nil
  4266  }
  4267  
  4268  func (m *RefreshTabletReplicationSourceResponse) MarshalVT() (dAtA []byte, err error) {
  4269  	if m == nil {
  4270  		return nil, nil
  4271  	}
  4272  	size := m.SizeVT()
  4273  	dAtA = make([]byte, size)
  4274  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4275  	if err != nil {
  4276  		return nil, err
  4277  	}
  4278  	return dAtA[:n], nil
  4279  }
  4280  
  4281  func (m *RefreshTabletReplicationSourceResponse) MarshalToVT(dAtA []byte) (int, error) {
  4282  	size := m.SizeVT()
  4283  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4284  }
  4285  
  4286  func (m *RefreshTabletReplicationSourceResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4287  	if m == nil {
  4288  		return 0, nil
  4289  	}
  4290  	i := len(dAtA)
  4291  	_ = i
  4292  	var l int
  4293  	_ = l
  4294  	if m.unknownFields != nil {
  4295  		i -= len(m.unknownFields)
  4296  		copy(dAtA[i:], m.unknownFields)
  4297  	}
  4298  	if m.Cluster != nil {
  4299  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  4300  		if err != nil {
  4301  			return 0, err
  4302  		}
  4303  		i -= size
  4304  		i = encodeVarint(dAtA, i, uint64(size))
  4305  		i--
  4306  		dAtA[i] = 0x22
  4307  	}
  4308  	if m.Primary != nil {
  4309  		size, err := m.Primary.MarshalToSizedBufferVT(dAtA[:i])
  4310  		if err != nil {
  4311  			return 0, err
  4312  		}
  4313  		i -= size
  4314  		i = encodeVarint(dAtA, i, uint64(size))
  4315  		i--
  4316  		dAtA[i] = 0x1a
  4317  	}
  4318  	if len(m.Shard) > 0 {
  4319  		i -= len(m.Shard)
  4320  		copy(dAtA[i:], m.Shard)
  4321  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  4322  		i--
  4323  		dAtA[i] = 0x12
  4324  	}
  4325  	if len(m.Keyspace) > 0 {
  4326  		i -= len(m.Keyspace)
  4327  		copy(dAtA[i:], m.Keyspace)
  4328  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  4329  		i--
  4330  		dAtA[i] = 0xa
  4331  	}
  4332  	return len(dAtA) - i, nil
  4333  }
  4334  
  4335  func (m *RemoveKeyspaceCellRequest) MarshalVT() (dAtA []byte, err error) {
  4336  	if m == nil {
  4337  		return nil, nil
  4338  	}
  4339  	size := m.SizeVT()
  4340  	dAtA = make([]byte, size)
  4341  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4342  	if err != nil {
  4343  		return nil, err
  4344  	}
  4345  	return dAtA[:n], nil
  4346  }
  4347  
  4348  func (m *RemoveKeyspaceCellRequest) MarshalToVT(dAtA []byte) (int, error) {
  4349  	size := m.SizeVT()
  4350  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4351  }
  4352  
  4353  func (m *RemoveKeyspaceCellRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4354  	if m == nil {
  4355  		return 0, nil
  4356  	}
  4357  	i := len(dAtA)
  4358  	_ = i
  4359  	var l int
  4360  	_ = l
  4361  	if m.unknownFields != nil {
  4362  		i -= len(m.unknownFields)
  4363  		copy(dAtA[i:], m.unknownFields)
  4364  	}
  4365  	if m.Recursive {
  4366  		i--
  4367  		if m.Recursive {
  4368  			dAtA[i] = 1
  4369  		} else {
  4370  			dAtA[i] = 0
  4371  		}
  4372  		i--
  4373  		dAtA[i] = 0x28
  4374  	}
  4375  	if m.Force {
  4376  		i--
  4377  		if m.Force {
  4378  			dAtA[i] = 1
  4379  		} else {
  4380  			dAtA[i] = 0
  4381  		}
  4382  		i--
  4383  		dAtA[i] = 0x20
  4384  	}
  4385  	if len(m.Cell) > 0 {
  4386  		i -= len(m.Cell)
  4387  		copy(dAtA[i:], m.Cell)
  4388  		i = encodeVarint(dAtA, i, uint64(len(m.Cell)))
  4389  		i--
  4390  		dAtA[i] = 0x1a
  4391  	}
  4392  	if len(m.Keyspace) > 0 {
  4393  		i -= len(m.Keyspace)
  4394  		copy(dAtA[i:], m.Keyspace)
  4395  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  4396  		i--
  4397  		dAtA[i] = 0x12
  4398  	}
  4399  	if len(m.ClusterId) > 0 {
  4400  		i -= len(m.ClusterId)
  4401  		copy(dAtA[i:], m.ClusterId)
  4402  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  4403  		i--
  4404  		dAtA[i] = 0xa
  4405  	}
  4406  	return len(dAtA) - i, nil
  4407  }
  4408  
  4409  func (m *RemoveKeyspaceCellResponse) MarshalVT() (dAtA []byte, err error) {
  4410  	if m == nil {
  4411  		return nil, nil
  4412  	}
  4413  	size := m.SizeVT()
  4414  	dAtA = make([]byte, size)
  4415  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4416  	if err != nil {
  4417  		return nil, err
  4418  	}
  4419  	return dAtA[:n], nil
  4420  }
  4421  
  4422  func (m *RemoveKeyspaceCellResponse) MarshalToVT(dAtA []byte) (int, error) {
  4423  	size := m.SizeVT()
  4424  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4425  }
  4426  
  4427  func (m *RemoveKeyspaceCellResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4428  	if m == nil {
  4429  		return 0, nil
  4430  	}
  4431  	i := len(dAtA)
  4432  	_ = i
  4433  	var l int
  4434  	_ = l
  4435  	if m.unknownFields != nil {
  4436  		i -= len(m.unknownFields)
  4437  		copy(dAtA[i:], m.unknownFields)
  4438  	}
  4439  	if len(m.Status) > 0 {
  4440  		i -= len(m.Status)
  4441  		copy(dAtA[i:], m.Status)
  4442  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  4443  		i--
  4444  		dAtA[i] = 0xa
  4445  	}
  4446  	return len(dAtA) - i, nil
  4447  }
  4448  
  4449  func (m *RunHealthCheckRequest) MarshalVT() (dAtA []byte, err error) {
  4450  	if m == nil {
  4451  		return nil, nil
  4452  	}
  4453  	size := m.SizeVT()
  4454  	dAtA = make([]byte, size)
  4455  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4456  	if err != nil {
  4457  		return nil, err
  4458  	}
  4459  	return dAtA[:n], nil
  4460  }
  4461  
  4462  func (m *RunHealthCheckRequest) MarshalToVT(dAtA []byte) (int, error) {
  4463  	size := m.SizeVT()
  4464  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4465  }
  4466  
  4467  func (m *RunHealthCheckRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4468  	if m == nil {
  4469  		return 0, nil
  4470  	}
  4471  	i := len(dAtA)
  4472  	_ = i
  4473  	var l int
  4474  	_ = l
  4475  	if m.unknownFields != nil {
  4476  		i -= len(m.unknownFields)
  4477  		copy(dAtA[i:], m.unknownFields)
  4478  	}
  4479  	if len(m.ClusterIds) > 0 {
  4480  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4481  			i -= len(m.ClusterIds[iNdEx])
  4482  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4483  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4484  			i--
  4485  			dAtA[i] = 0x12
  4486  		}
  4487  	}
  4488  	if m.Alias != nil {
  4489  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4490  		if err != nil {
  4491  			return 0, err
  4492  		}
  4493  		i -= size
  4494  		i = encodeVarint(dAtA, i, uint64(size))
  4495  		i--
  4496  		dAtA[i] = 0xa
  4497  	}
  4498  	return len(dAtA) - i, nil
  4499  }
  4500  
  4501  func (m *RunHealthCheckResponse) MarshalVT() (dAtA []byte, err error) {
  4502  	if m == nil {
  4503  		return nil, nil
  4504  	}
  4505  	size := m.SizeVT()
  4506  	dAtA = make([]byte, size)
  4507  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4508  	if err != nil {
  4509  		return nil, err
  4510  	}
  4511  	return dAtA[:n], nil
  4512  }
  4513  
  4514  func (m *RunHealthCheckResponse) MarshalToVT(dAtA []byte) (int, error) {
  4515  	size := m.SizeVT()
  4516  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4517  }
  4518  
  4519  func (m *RunHealthCheckResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4520  	if m == nil {
  4521  		return 0, nil
  4522  	}
  4523  	i := len(dAtA)
  4524  	_ = i
  4525  	var l int
  4526  	_ = l
  4527  	if m.unknownFields != nil {
  4528  		i -= len(m.unknownFields)
  4529  		copy(dAtA[i:], m.unknownFields)
  4530  	}
  4531  	if m.Cluster != nil {
  4532  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  4533  		if err != nil {
  4534  			return 0, err
  4535  		}
  4536  		i -= size
  4537  		i = encodeVarint(dAtA, i, uint64(size))
  4538  		i--
  4539  		dAtA[i] = 0x12
  4540  	}
  4541  	if len(m.Status) > 0 {
  4542  		i -= len(m.Status)
  4543  		copy(dAtA[i:], m.Status)
  4544  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  4545  		i--
  4546  		dAtA[i] = 0xa
  4547  	}
  4548  	return len(dAtA) - i, nil
  4549  }
  4550  
  4551  func (m *SetReadOnlyRequest) MarshalVT() (dAtA []byte, err error) {
  4552  	if m == nil {
  4553  		return nil, nil
  4554  	}
  4555  	size := m.SizeVT()
  4556  	dAtA = make([]byte, size)
  4557  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4558  	if err != nil {
  4559  		return nil, err
  4560  	}
  4561  	return dAtA[:n], nil
  4562  }
  4563  
  4564  func (m *SetReadOnlyRequest) MarshalToVT(dAtA []byte) (int, error) {
  4565  	size := m.SizeVT()
  4566  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4567  }
  4568  
  4569  func (m *SetReadOnlyRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4570  	if m == nil {
  4571  		return 0, nil
  4572  	}
  4573  	i := len(dAtA)
  4574  	_ = i
  4575  	var l int
  4576  	_ = l
  4577  	if m.unknownFields != nil {
  4578  		i -= len(m.unknownFields)
  4579  		copy(dAtA[i:], m.unknownFields)
  4580  	}
  4581  	if len(m.ClusterIds) > 0 {
  4582  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4583  			i -= len(m.ClusterIds[iNdEx])
  4584  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4585  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4586  			i--
  4587  			dAtA[i] = 0x12
  4588  		}
  4589  	}
  4590  	if m.Alias != nil {
  4591  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4592  		if err != nil {
  4593  			return 0, err
  4594  		}
  4595  		i -= size
  4596  		i = encodeVarint(dAtA, i, uint64(size))
  4597  		i--
  4598  		dAtA[i] = 0xa
  4599  	}
  4600  	return len(dAtA) - i, nil
  4601  }
  4602  
  4603  func (m *SetReadOnlyResponse) MarshalVT() (dAtA []byte, err error) {
  4604  	if m == nil {
  4605  		return nil, nil
  4606  	}
  4607  	size := m.SizeVT()
  4608  	dAtA = make([]byte, size)
  4609  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4610  	if err != nil {
  4611  		return nil, err
  4612  	}
  4613  	return dAtA[:n], nil
  4614  }
  4615  
  4616  func (m *SetReadOnlyResponse) MarshalToVT(dAtA []byte) (int, error) {
  4617  	size := m.SizeVT()
  4618  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4619  }
  4620  
  4621  func (m *SetReadOnlyResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4622  	if m == nil {
  4623  		return 0, nil
  4624  	}
  4625  	i := len(dAtA)
  4626  	_ = i
  4627  	var l int
  4628  	_ = l
  4629  	if m.unknownFields != nil {
  4630  		i -= len(m.unknownFields)
  4631  		copy(dAtA[i:], m.unknownFields)
  4632  	}
  4633  	return len(dAtA) - i, nil
  4634  }
  4635  
  4636  func (m *SetReadWriteRequest) MarshalVT() (dAtA []byte, err error) {
  4637  	if m == nil {
  4638  		return nil, nil
  4639  	}
  4640  	size := m.SizeVT()
  4641  	dAtA = make([]byte, size)
  4642  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4643  	if err != nil {
  4644  		return nil, err
  4645  	}
  4646  	return dAtA[:n], nil
  4647  }
  4648  
  4649  func (m *SetReadWriteRequest) MarshalToVT(dAtA []byte) (int, error) {
  4650  	size := m.SizeVT()
  4651  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4652  }
  4653  
  4654  func (m *SetReadWriteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4655  	if m == nil {
  4656  		return 0, nil
  4657  	}
  4658  	i := len(dAtA)
  4659  	_ = i
  4660  	var l int
  4661  	_ = l
  4662  	if m.unknownFields != nil {
  4663  		i -= len(m.unknownFields)
  4664  		copy(dAtA[i:], m.unknownFields)
  4665  	}
  4666  	if len(m.ClusterIds) > 0 {
  4667  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4668  			i -= len(m.ClusterIds[iNdEx])
  4669  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4670  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4671  			i--
  4672  			dAtA[i] = 0x12
  4673  		}
  4674  	}
  4675  	if m.Alias != nil {
  4676  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4677  		if err != nil {
  4678  			return 0, err
  4679  		}
  4680  		i -= size
  4681  		i = encodeVarint(dAtA, i, uint64(size))
  4682  		i--
  4683  		dAtA[i] = 0xa
  4684  	}
  4685  	return len(dAtA) - i, nil
  4686  }
  4687  
  4688  func (m *SetReadWriteResponse) MarshalVT() (dAtA []byte, err error) {
  4689  	if m == nil {
  4690  		return nil, nil
  4691  	}
  4692  	size := m.SizeVT()
  4693  	dAtA = make([]byte, size)
  4694  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4695  	if err != nil {
  4696  		return nil, err
  4697  	}
  4698  	return dAtA[:n], nil
  4699  }
  4700  
  4701  func (m *SetReadWriteResponse) MarshalToVT(dAtA []byte) (int, error) {
  4702  	size := m.SizeVT()
  4703  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4704  }
  4705  
  4706  func (m *SetReadWriteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4707  	if m == nil {
  4708  		return 0, nil
  4709  	}
  4710  	i := len(dAtA)
  4711  	_ = i
  4712  	var l int
  4713  	_ = l
  4714  	if m.unknownFields != nil {
  4715  		i -= len(m.unknownFields)
  4716  		copy(dAtA[i:], m.unknownFields)
  4717  	}
  4718  	return len(dAtA) - i, nil
  4719  }
  4720  
  4721  func (m *StartReplicationRequest) MarshalVT() (dAtA []byte, err error) {
  4722  	if m == nil {
  4723  		return nil, nil
  4724  	}
  4725  	size := m.SizeVT()
  4726  	dAtA = make([]byte, size)
  4727  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4728  	if err != nil {
  4729  		return nil, err
  4730  	}
  4731  	return dAtA[:n], nil
  4732  }
  4733  
  4734  func (m *StartReplicationRequest) MarshalToVT(dAtA []byte) (int, error) {
  4735  	size := m.SizeVT()
  4736  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4737  }
  4738  
  4739  func (m *StartReplicationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4740  	if m == nil {
  4741  		return 0, nil
  4742  	}
  4743  	i := len(dAtA)
  4744  	_ = i
  4745  	var l int
  4746  	_ = l
  4747  	if m.unknownFields != nil {
  4748  		i -= len(m.unknownFields)
  4749  		copy(dAtA[i:], m.unknownFields)
  4750  	}
  4751  	if len(m.ClusterIds) > 0 {
  4752  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4753  			i -= len(m.ClusterIds[iNdEx])
  4754  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4755  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4756  			i--
  4757  			dAtA[i] = 0x12
  4758  		}
  4759  	}
  4760  	if m.Alias != nil {
  4761  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4762  		if err != nil {
  4763  			return 0, err
  4764  		}
  4765  		i -= size
  4766  		i = encodeVarint(dAtA, i, uint64(size))
  4767  		i--
  4768  		dAtA[i] = 0xa
  4769  	}
  4770  	return len(dAtA) - i, nil
  4771  }
  4772  
  4773  func (m *StartReplicationResponse) MarshalVT() (dAtA []byte, err error) {
  4774  	if m == nil {
  4775  		return nil, nil
  4776  	}
  4777  	size := m.SizeVT()
  4778  	dAtA = make([]byte, size)
  4779  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4780  	if err != nil {
  4781  		return nil, err
  4782  	}
  4783  	return dAtA[:n], nil
  4784  }
  4785  
  4786  func (m *StartReplicationResponse) MarshalToVT(dAtA []byte) (int, error) {
  4787  	size := m.SizeVT()
  4788  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4789  }
  4790  
  4791  func (m *StartReplicationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4792  	if m == nil {
  4793  		return 0, nil
  4794  	}
  4795  	i := len(dAtA)
  4796  	_ = i
  4797  	var l int
  4798  	_ = l
  4799  	if m.unknownFields != nil {
  4800  		i -= len(m.unknownFields)
  4801  		copy(dAtA[i:], m.unknownFields)
  4802  	}
  4803  	if m.Cluster != nil {
  4804  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  4805  		if err != nil {
  4806  			return 0, err
  4807  		}
  4808  		i -= size
  4809  		i = encodeVarint(dAtA, i, uint64(size))
  4810  		i--
  4811  		dAtA[i] = 0x12
  4812  	}
  4813  	if len(m.Status) > 0 {
  4814  		i -= len(m.Status)
  4815  		copy(dAtA[i:], m.Status)
  4816  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  4817  		i--
  4818  		dAtA[i] = 0xa
  4819  	}
  4820  	return len(dAtA) - i, nil
  4821  }
  4822  
  4823  func (m *StopReplicationRequest) MarshalVT() (dAtA []byte, err error) {
  4824  	if m == nil {
  4825  		return nil, nil
  4826  	}
  4827  	size := m.SizeVT()
  4828  	dAtA = make([]byte, size)
  4829  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4830  	if err != nil {
  4831  		return nil, err
  4832  	}
  4833  	return dAtA[:n], nil
  4834  }
  4835  
  4836  func (m *StopReplicationRequest) MarshalToVT(dAtA []byte) (int, error) {
  4837  	size := m.SizeVT()
  4838  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4839  }
  4840  
  4841  func (m *StopReplicationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4842  	if m == nil {
  4843  		return 0, nil
  4844  	}
  4845  	i := len(dAtA)
  4846  	_ = i
  4847  	var l int
  4848  	_ = l
  4849  	if m.unknownFields != nil {
  4850  		i -= len(m.unknownFields)
  4851  		copy(dAtA[i:], m.unknownFields)
  4852  	}
  4853  	if len(m.ClusterIds) > 0 {
  4854  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4855  			i -= len(m.ClusterIds[iNdEx])
  4856  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4857  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4858  			i--
  4859  			dAtA[i] = 0x12
  4860  		}
  4861  	}
  4862  	if m.Alias != nil {
  4863  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4864  		if err != nil {
  4865  			return 0, err
  4866  		}
  4867  		i -= size
  4868  		i = encodeVarint(dAtA, i, uint64(size))
  4869  		i--
  4870  		dAtA[i] = 0xa
  4871  	}
  4872  	return len(dAtA) - i, nil
  4873  }
  4874  
  4875  func (m *StopReplicationResponse) MarshalVT() (dAtA []byte, err error) {
  4876  	if m == nil {
  4877  		return nil, nil
  4878  	}
  4879  	size := m.SizeVT()
  4880  	dAtA = make([]byte, size)
  4881  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4882  	if err != nil {
  4883  		return nil, err
  4884  	}
  4885  	return dAtA[:n], nil
  4886  }
  4887  
  4888  func (m *StopReplicationResponse) MarshalToVT(dAtA []byte) (int, error) {
  4889  	size := m.SizeVT()
  4890  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4891  }
  4892  
  4893  func (m *StopReplicationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4894  	if m == nil {
  4895  		return 0, nil
  4896  	}
  4897  	i := len(dAtA)
  4898  	_ = i
  4899  	var l int
  4900  	_ = l
  4901  	if m.unknownFields != nil {
  4902  		i -= len(m.unknownFields)
  4903  		copy(dAtA[i:], m.unknownFields)
  4904  	}
  4905  	if m.Cluster != nil {
  4906  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  4907  		if err != nil {
  4908  			return 0, err
  4909  		}
  4910  		i -= size
  4911  		i = encodeVarint(dAtA, i, uint64(size))
  4912  		i--
  4913  		dAtA[i] = 0x12
  4914  	}
  4915  	if len(m.Status) > 0 {
  4916  		i -= len(m.Status)
  4917  		copy(dAtA[i:], m.Status)
  4918  		i = encodeVarint(dAtA, i, uint64(len(m.Status)))
  4919  		i--
  4920  		dAtA[i] = 0xa
  4921  	}
  4922  	return len(dAtA) - i, nil
  4923  }
  4924  
  4925  func (m *TabletExternallyPromotedRequest) MarshalVT() (dAtA []byte, err error) {
  4926  	if m == nil {
  4927  		return nil, nil
  4928  	}
  4929  	size := m.SizeVT()
  4930  	dAtA = make([]byte, size)
  4931  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4932  	if err != nil {
  4933  		return nil, err
  4934  	}
  4935  	return dAtA[:n], nil
  4936  }
  4937  
  4938  func (m *TabletExternallyPromotedRequest) MarshalToVT(dAtA []byte) (int, error) {
  4939  	size := m.SizeVT()
  4940  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4941  }
  4942  
  4943  func (m *TabletExternallyPromotedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4944  	if m == nil {
  4945  		return 0, nil
  4946  	}
  4947  	i := len(dAtA)
  4948  	_ = i
  4949  	var l int
  4950  	_ = l
  4951  	if m.unknownFields != nil {
  4952  		i -= len(m.unknownFields)
  4953  		copy(dAtA[i:], m.unknownFields)
  4954  	}
  4955  	if len(m.ClusterIds) > 0 {
  4956  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  4957  			i -= len(m.ClusterIds[iNdEx])
  4958  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  4959  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  4960  			i--
  4961  			dAtA[i] = 0x12
  4962  		}
  4963  	}
  4964  	if m.Alias != nil {
  4965  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  4966  		if err != nil {
  4967  			return 0, err
  4968  		}
  4969  		i -= size
  4970  		i = encodeVarint(dAtA, i, uint64(size))
  4971  		i--
  4972  		dAtA[i] = 0xa
  4973  	}
  4974  	return len(dAtA) - i, nil
  4975  }
  4976  
  4977  func (m *TabletExternallyPromotedResponse) MarshalVT() (dAtA []byte, err error) {
  4978  	if m == nil {
  4979  		return nil, nil
  4980  	}
  4981  	size := m.SizeVT()
  4982  	dAtA = make([]byte, size)
  4983  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4984  	if err != nil {
  4985  		return nil, err
  4986  	}
  4987  	return dAtA[:n], nil
  4988  }
  4989  
  4990  func (m *TabletExternallyPromotedResponse) MarshalToVT(dAtA []byte) (int, error) {
  4991  	size := m.SizeVT()
  4992  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4993  }
  4994  
  4995  func (m *TabletExternallyPromotedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4996  	if m == nil {
  4997  		return 0, nil
  4998  	}
  4999  	i := len(dAtA)
  5000  	_ = i
  5001  	var l int
  5002  	_ = l
  5003  	if m.unknownFields != nil {
  5004  		i -= len(m.unknownFields)
  5005  		copy(dAtA[i:], m.unknownFields)
  5006  	}
  5007  	if m.OldPrimary != nil {
  5008  		size, err := m.OldPrimary.MarshalToSizedBufferVT(dAtA[:i])
  5009  		if err != nil {
  5010  			return 0, err
  5011  		}
  5012  		i -= size
  5013  		i = encodeVarint(dAtA, i, uint64(size))
  5014  		i--
  5015  		dAtA[i] = 0x2a
  5016  	}
  5017  	if m.NewPrimary != nil {
  5018  		size, err := m.NewPrimary.MarshalToSizedBufferVT(dAtA[:i])
  5019  		if err != nil {
  5020  			return 0, err
  5021  		}
  5022  		i -= size
  5023  		i = encodeVarint(dAtA, i, uint64(size))
  5024  		i--
  5025  		dAtA[i] = 0x22
  5026  	}
  5027  	if len(m.Shard) > 0 {
  5028  		i -= len(m.Shard)
  5029  		copy(dAtA[i:], m.Shard)
  5030  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  5031  		i--
  5032  		dAtA[i] = 0x1a
  5033  	}
  5034  	if len(m.Keyspace) > 0 {
  5035  		i -= len(m.Keyspace)
  5036  		copy(dAtA[i:], m.Keyspace)
  5037  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5038  		i--
  5039  		dAtA[i] = 0x12
  5040  	}
  5041  	if m.Cluster != nil {
  5042  		size, err := m.Cluster.MarshalToSizedBufferVT(dAtA[:i])
  5043  		if err != nil {
  5044  			return 0, err
  5045  		}
  5046  		i -= size
  5047  		i = encodeVarint(dAtA, i, uint64(size))
  5048  		i--
  5049  		dAtA[i] = 0xa
  5050  	}
  5051  	return len(dAtA) - i, nil
  5052  }
  5053  
  5054  func (m *TabletExternallyReparentedRequest) MarshalVT() (dAtA []byte, err error) {
  5055  	if m == nil {
  5056  		return nil, nil
  5057  	}
  5058  	size := m.SizeVT()
  5059  	dAtA = make([]byte, size)
  5060  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5061  	if err != nil {
  5062  		return nil, err
  5063  	}
  5064  	return dAtA[:n], nil
  5065  }
  5066  
  5067  func (m *TabletExternallyReparentedRequest) MarshalToVT(dAtA []byte) (int, error) {
  5068  	size := m.SizeVT()
  5069  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5070  }
  5071  
  5072  func (m *TabletExternallyReparentedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5073  	if m == nil {
  5074  		return 0, nil
  5075  	}
  5076  	i := len(dAtA)
  5077  	_ = i
  5078  	var l int
  5079  	_ = l
  5080  	if m.unknownFields != nil {
  5081  		i -= len(m.unknownFields)
  5082  		copy(dAtA[i:], m.unknownFields)
  5083  	}
  5084  	if len(m.ClusterIds) > 0 {
  5085  		for iNdEx := len(m.ClusterIds) - 1; iNdEx >= 0; iNdEx-- {
  5086  			i -= len(m.ClusterIds[iNdEx])
  5087  			copy(dAtA[i:], m.ClusterIds[iNdEx])
  5088  			i = encodeVarint(dAtA, i, uint64(len(m.ClusterIds[iNdEx])))
  5089  			i--
  5090  			dAtA[i] = 0x12
  5091  		}
  5092  	}
  5093  	if m.Alias != nil {
  5094  		size, err := m.Alias.MarshalToSizedBufferVT(dAtA[:i])
  5095  		if err != nil {
  5096  			return 0, err
  5097  		}
  5098  		i -= size
  5099  		i = encodeVarint(dAtA, i, uint64(size))
  5100  		i--
  5101  		dAtA[i] = 0xa
  5102  	}
  5103  	return len(dAtA) - i, nil
  5104  }
  5105  
  5106  func (m *ValidateRequest) MarshalVT() (dAtA []byte, err error) {
  5107  	if m == nil {
  5108  		return nil, nil
  5109  	}
  5110  	size := m.SizeVT()
  5111  	dAtA = make([]byte, size)
  5112  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5113  	if err != nil {
  5114  		return nil, err
  5115  	}
  5116  	return dAtA[:n], nil
  5117  }
  5118  
  5119  func (m *ValidateRequest) MarshalToVT(dAtA []byte) (int, error) {
  5120  	size := m.SizeVT()
  5121  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5122  }
  5123  
  5124  func (m *ValidateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5125  	if m == nil {
  5126  		return 0, nil
  5127  	}
  5128  	i := len(dAtA)
  5129  	_ = i
  5130  	var l int
  5131  	_ = l
  5132  	if m.unknownFields != nil {
  5133  		i -= len(m.unknownFields)
  5134  		copy(dAtA[i:], m.unknownFields)
  5135  	}
  5136  	if m.PingTablets {
  5137  		i--
  5138  		if m.PingTablets {
  5139  			dAtA[i] = 1
  5140  		} else {
  5141  			dAtA[i] = 0
  5142  		}
  5143  		i--
  5144  		dAtA[i] = 0x10
  5145  	}
  5146  	if len(m.ClusterId) > 0 {
  5147  		i -= len(m.ClusterId)
  5148  		copy(dAtA[i:], m.ClusterId)
  5149  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  5150  		i--
  5151  		dAtA[i] = 0xa
  5152  	}
  5153  	return len(dAtA) - i, nil
  5154  }
  5155  
  5156  func (m *ValidateKeyspaceRequest) MarshalVT() (dAtA []byte, err error) {
  5157  	if m == nil {
  5158  		return nil, nil
  5159  	}
  5160  	size := m.SizeVT()
  5161  	dAtA = make([]byte, size)
  5162  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5163  	if err != nil {
  5164  		return nil, err
  5165  	}
  5166  	return dAtA[:n], nil
  5167  }
  5168  
  5169  func (m *ValidateKeyspaceRequest) MarshalToVT(dAtA []byte) (int, error) {
  5170  	size := m.SizeVT()
  5171  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5172  }
  5173  
  5174  func (m *ValidateKeyspaceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5175  	if m == nil {
  5176  		return 0, nil
  5177  	}
  5178  	i := len(dAtA)
  5179  	_ = i
  5180  	var l int
  5181  	_ = l
  5182  	if m.unknownFields != nil {
  5183  		i -= len(m.unknownFields)
  5184  		copy(dAtA[i:], m.unknownFields)
  5185  	}
  5186  	if m.PingTablets {
  5187  		i--
  5188  		if m.PingTablets {
  5189  			dAtA[i] = 1
  5190  		} else {
  5191  			dAtA[i] = 0
  5192  		}
  5193  		i--
  5194  		dAtA[i] = 0x18
  5195  	}
  5196  	if len(m.Keyspace) > 0 {
  5197  		i -= len(m.Keyspace)
  5198  		copy(dAtA[i:], m.Keyspace)
  5199  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5200  		i--
  5201  		dAtA[i] = 0x12
  5202  	}
  5203  	if len(m.ClusterId) > 0 {
  5204  		i -= len(m.ClusterId)
  5205  		copy(dAtA[i:], m.ClusterId)
  5206  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  5207  		i--
  5208  		dAtA[i] = 0xa
  5209  	}
  5210  	return len(dAtA) - i, nil
  5211  }
  5212  
  5213  func (m *ValidateSchemaKeyspaceRequest) MarshalVT() (dAtA []byte, err error) {
  5214  	if m == nil {
  5215  		return nil, nil
  5216  	}
  5217  	size := m.SizeVT()
  5218  	dAtA = make([]byte, size)
  5219  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5220  	if err != nil {
  5221  		return nil, err
  5222  	}
  5223  	return dAtA[:n], nil
  5224  }
  5225  
  5226  func (m *ValidateSchemaKeyspaceRequest) MarshalToVT(dAtA []byte) (int, error) {
  5227  	size := m.SizeVT()
  5228  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5229  }
  5230  
  5231  func (m *ValidateSchemaKeyspaceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5232  	if m == nil {
  5233  		return 0, nil
  5234  	}
  5235  	i := len(dAtA)
  5236  	_ = i
  5237  	var l int
  5238  	_ = l
  5239  	if m.unknownFields != nil {
  5240  		i -= len(m.unknownFields)
  5241  		copy(dAtA[i:], m.unknownFields)
  5242  	}
  5243  	if len(m.Keyspace) > 0 {
  5244  		i -= len(m.Keyspace)
  5245  		copy(dAtA[i:], m.Keyspace)
  5246  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5247  		i--
  5248  		dAtA[i] = 0x12
  5249  	}
  5250  	if len(m.ClusterId) > 0 {
  5251  		i -= len(m.ClusterId)
  5252  		copy(dAtA[i:], m.ClusterId)
  5253  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  5254  		i--
  5255  		dAtA[i] = 0xa
  5256  	}
  5257  	return len(dAtA) - i, nil
  5258  }
  5259  
  5260  func (m *ValidateShardRequest) MarshalVT() (dAtA []byte, err error) {
  5261  	if m == nil {
  5262  		return nil, nil
  5263  	}
  5264  	size := m.SizeVT()
  5265  	dAtA = make([]byte, size)
  5266  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5267  	if err != nil {
  5268  		return nil, err
  5269  	}
  5270  	return dAtA[:n], nil
  5271  }
  5272  
  5273  func (m *ValidateShardRequest) MarshalToVT(dAtA []byte) (int, error) {
  5274  	size := m.SizeVT()
  5275  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5276  }
  5277  
  5278  func (m *ValidateShardRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5279  	if m == nil {
  5280  		return 0, nil
  5281  	}
  5282  	i := len(dAtA)
  5283  	_ = i
  5284  	var l int
  5285  	_ = l
  5286  	if m.unknownFields != nil {
  5287  		i -= len(m.unknownFields)
  5288  		copy(dAtA[i:], m.unknownFields)
  5289  	}
  5290  	if m.PingTablets {
  5291  		i--
  5292  		if m.PingTablets {
  5293  			dAtA[i] = 1
  5294  		} else {
  5295  			dAtA[i] = 0
  5296  		}
  5297  		i--
  5298  		dAtA[i] = 0x20
  5299  	}
  5300  	if len(m.Shard) > 0 {
  5301  		i -= len(m.Shard)
  5302  		copy(dAtA[i:], m.Shard)
  5303  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  5304  		i--
  5305  		dAtA[i] = 0x1a
  5306  	}
  5307  	if len(m.Keyspace) > 0 {
  5308  		i -= len(m.Keyspace)
  5309  		copy(dAtA[i:], m.Keyspace)
  5310  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5311  		i--
  5312  		dAtA[i] = 0x12
  5313  	}
  5314  	if len(m.ClusterId) > 0 {
  5315  		i -= len(m.ClusterId)
  5316  		copy(dAtA[i:], m.ClusterId)
  5317  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  5318  		i--
  5319  		dAtA[i] = 0xa
  5320  	}
  5321  	return len(dAtA) - i, nil
  5322  }
  5323  
  5324  func (m *ValidateVersionKeyspaceRequest) MarshalVT() (dAtA []byte, err error) {
  5325  	if m == nil {
  5326  		return nil, nil
  5327  	}
  5328  	size := m.SizeVT()
  5329  	dAtA = make([]byte, size)
  5330  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5331  	if err != nil {
  5332  		return nil, err
  5333  	}
  5334  	return dAtA[:n], nil
  5335  }
  5336  
  5337  func (m *ValidateVersionKeyspaceRequest) MarshalToVT(dAtA []byte) (int, error) {
  5338  	size := m.SizeVT()
  5339  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5340  }
  5341  
  5342  func (m *ValidateVersionKeyspaceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5343  	if m == nil {
  5344  		return 0, nil
  5345  	}
  5346  	i := len(dAtA)
  5347  	_ = i
  5348  	var l int
  5349  	_ = l
  5350  	if m.unknownFields != nil {
  5351  		i -= len(m.unknownFields)
  5352  		copy(dAtA[i:], m.unknownFields)
  5353  	}
  5354  	if len(m.Keyspace) > 0 {
  5355  		i -= len(m.Keyspace)
  5356  		copy(dAtA[i:], m.Keyspace)
  5357  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5358  		i--
  5359  		dAtA[i] = 0x12
  5360  	}
  5361  	if len(m.ClusterId) > 0 {
  5362  		i -= len(m.ClusterId)
  5363  		copy(dAtA[i:], m.ClusterId)
  5364  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  5365  		i--
  5366  		dAtA[i] = 0xa
  5367  	}
  5368  	return len(dAtA) - i, nil
  5369  }
  5370  
  5371  func (m *ValidateVersionShardRequest) MarshalVT() (dAtA []byte, err error) {
  5372  	if m == nil {
  5373  		return nil, nil
  5374  	}
  5375  	size := m.SizeVT()
  5376  	dAtA = make([]byte, size)
  5377  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5378  	if err != nil {
  5379  		return nil, err
  5380  	}
  5381  	return dAtA[:n], nil
  5382  }
  5383  
  5384  func (m *ValidateVersionShardRequest) MarshalToVT(dAtA []byte) (int, error) {
  5385  	size := m.SizeVT()
  5386  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5387  }
  5388  
  5389  func (m *ValidateVersionShardRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5390  	if m == nil {
  5391  		return 0, nil
  5392  	}
  5393  	i := len(dAtA)
  5394  	_ = i
  5395  	var l int
  5396  	_ = l
  5397  	if m.unknownFields != nil {
  5398  		i -= len(m.unknownFields)
  5399  		copy(dAtA[i:], m.unknownFields)
  5400  	}
  5401  	if len(m.Shard) > 0 {
  5402  		i -= len(m.Shard)
  5403  		copy(dAtA[i:], m.Shard)
  5404  		i = encodeVarint(dAtA, i, uint64(len(m.Shard)))
  5405  		i--
  5406  		dAtA[i] = 0x1a
  5407  	}
  5408  	if len(m.Keyspace) > 0 {
  5409  		i -= len(m.Keyspace)
  5410  		copy(dAtA[i:], m.Keyspace)
  5411  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5412  		i--
  5413  		dAtA[i] = 0x12
  5414  	}
  5415  	if len(m.ClusterId) > 0 {
  5416  		i -= len(m.ClusterId)
  5417  		copy(dAtA[i:], m.ClusterId)
  5418  		i = encodeVarint(dAtA, i, uint64(len(m.ClusterId)))
  5419  		i--
  5420  		dAtA[i] = 0xa
  5421  	}
  5422  	return len(dAtA) - i, nil
  5423  }
  5424  
  5425  func (m *VTExplainRequest) MarshalVT() (dAtA []byte, err error) {
  5426  	if m == nil {
  5427  		return nil, nil
  5428  	}
  5429  	size := m.SizeVT()
  5430  	dAtA = make([]byte, size)
  5431  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5432  	if err != nil {
  5433  		return nil, err
  5434  	}
  5435  	return dAtA[:n], nil
  5436  }
  5437  
  5438  func (m *VTExplainRequest) MarshalToVT(dAtA []byte) (int, error) {
  5439  	size := m.SizeVT()
  5440  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5441  }
  5442  
  5443  func (m *VTExplainRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5444  	if m == nil {
  5445  		return 0, nil
  5446  	}
  5447  	i := len(dAtA)
  5448  	_ = i
  5449  	var l int
  5450  	_ = l
  5451  	if m.unknownFields != nil {
  5452  		i -= len(m.unknownFields)
  5453  		copy(dAtA[i:], m.unknownFields)
  5454  	}
  5455  	if len(m.Sql) > 0 {
  5456  		i -= len(m.Sql)
  5457  		copy(dAtA[i:], m.Sql)
  5458  		i = encodeVarint(dAtA, i, uint64(len(m.Sql)))
  5459  		i--
  5460  		dAtA[i] = 0x1a
  5461  	}
  5462  	if len(m.Keyspace) > 0 {
  5463  		i -= len(m.Keyspace)
  5464  		copy(dAtA[i:], m.Keyspace)
  5465  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  5466  		i--
  5467  		dAtA[i] = 0x12
  5468  	}
  5469  	if len(m.Cluster) > 0 {
  5470  		i -= len(m.Cluster)
  5471  		copy(dAtA[i:], m.Cluster)
  5472  		i = encodeVarint(dAtA, i, uint64(len(m.Cluster)))
  5473  		i--
  5474  		dAtA[i] = 0xa
  5475  	}
  5476  	return len(dAtA) - i, nil
  5477  }
  5478  
  5479  func (m *VTExplainResponse) MarshalVT() (dAtA []byte, err error) {
  5480  	if m == nil {
  5481  		return nil, nil
  5482  	}
  5483  	size := m.SizeVT()
  5484  	dAtA = make([]byte, size)
  5485  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  5486  	if err != nil {
  5487  		return nil, err
  5488  	}
  5489  	return dAtA[:n], nil
  5490  }
  5491  
  5492  func (m *VTExplainResponse) MarshalToVT(dAtA []byte) (int, error) {
  5493  	size := m.SizeVT()
  5494  	return m.MarshalToSizedBufferVT(dAtA[:size])
  5495  }
  5496  
  5497  func (m *VTExplainResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  5498  	if m == nil {
  5499  		return 0, nil
  5500  	}
  5501  	i := len(dAtA)
  5502  	_ = i
  5503  	var l int
  5504  	_ = l
  5505  	if m.unknownFields != nil {
  5506  		i -= len(m.unknownFields)
  5507  		copy(dAtA[i:], m.unknownFields)
  5508  	}
  5509  	if len(m.Response) > 0 {
  5510  		i -= len(m.Response)
  5511  		copy(dAtA[i:], m.Response)
  5512  		i = encodeVarint(dAtA, i, uint64(len(m.Response)))
  5513  		i--
  5514  		dAtA[i] = 0xa
  5515  	}
  5516  	return len(dAtA) - i, nil
  5517  }
  5518  
  5519  func encodeVarint(dAtA []byte, offset int, v uint64) int {
  5520  	offset -= sov(v)
  5521  	base := offset
  5522  	for v >= 1<<7 {
  5523  		dAtA[offset] = uint8(v&0x7f | 0x80)
  5524  		v >>= 7
  5525  		offset++
  5526  	}
  5527  	dAtA[offset] = uint8(v)
  5528  	return base
  5529  }
  5530  func (m *Cluster) SizeVT() (n int) {
  5531  	if m == nil {
  5532  		return 0
  5533  	}
  5534  	var l int
  5535  	_ = l
  5536  	l = len(m.Id)
  5537  	if l > 0 {
  5538  		n += 1 + l + sov(uint64(l))
  5539  	}
  5540  	l = len(m.Name)
  5541  	if l > 0 {
  5542  		n += 1 + l + sov(uint64(l))
  5543  	}
  5544  	n += len(m.unknownFields)
  5545  	return n
  5546  }
  5547  
  5548  func (m *ClusterBackup) SizeVT() (n int) {
  5549  	if m == nil {
  5550  		return 0
  5551  	}
  5552  	var l int
  5553  	_ = l
  5554  	if m.Cluster != nil {
  5555  		l = m.Cluster.SizeVT()
  5556  		n += 1 + l + sov(uint64(l))
  5557  	}
  5558  	if m.Backup != nil {
  5559  		l = m.Backup.SizeVT()
  5560  		n += 1 + l + sov(uint64(l))
  5561  	}
  5562  	n += len(m.unknownFields)
  5563  	return n
  5564  }
  5565  
  5566  func (m *ClusterCellsAliases) SizeVT() (n int) {
  5567  	if m == nil {
  5568  		return 0
  5569  	}
  5570  	var l int
  5571  	_ = l
  5572  	if m.Cluster != nil {
  5573  		l = m.Cluster.SizeVT()
  5574  		n += 1 + l + sov(uint64(l))
  5575  	}
  5576  	if len(m.Aliases) > 0 {
  5577  		for k, v := range m.Aliases {
  5578  			_ = k
  5579  			_ = v
  5580  			l = 0
  5581  			if v != nil {
  5582  				l = v.SizeVT()
  5583  			}
  5584  			l += 1 + sov(uint64(l))
  5585  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l
  5586  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  5587  		}
  5588  	}
  5589  	n += len(m.unknownFields)
  5590  	return n
  5591  }
  5592  
  5593  func (m *ClusterCellInfo) SizeVT() (n int) {
  5594  	if m == nil {
  5595  		return 0
  5596  	}
  5597  	var l int
  5598  	_ = l
  5599  	if m.Cluster != nil {
  5600  		l = m.Cluster.SizeVT()
  5601  		n += 1 + l + sov(uint64(l))
  5602  	}
  5603  	l = len(m.Name)
  5604  	if l > 0 {
  5605  		n += 1 + l + sov(uint64(l))
  5606  	}
  5607  	if m.CellInfo != nil {
  5608  		l = m.CellInfo.SizeVT()
  5609  		n += 1 + l + sov(uint64(l))
  5610  	}
  5611  	n += len(m.unknownFields)
  5612  	return n
  5613  }
  5614  
  5615  func (m *ClusterShardReplicationPosition) SizeVT() (n int) {
  5616  	if m == nil {
  5617  		return 0
  5618  	}
  5619  	var l int
  5620  	_ = l
  5621  	if m.Cluster != nil {
  5622  		l = m.Cluster.SizeVT()
  5623  		n += 1 + l + sov(uint64(l))
  5624  	}
  5625  	l = len(m.Keyspace)
  5626  	if l > 0 {
  5627  		n += 1 + l + sov(uint64(l))
  5628  	}
  5629  	l = len(m.Shard)
  5630  	if l > 0 {
  5631  		n += 1 + l + sov(uint64(l))
  5632  	}
  5633  	if m.PositionInfo != nil {
  5634  		l = m.PositionInfo.SizeVT()
  5635  		n += 1 + l + sov(uint64(l))
  5636  	}
  5637  	n += len(m.unknownFields)
  5638  	return n
  5639  }
  5640  
  5641  func (m *ClusterWorkflows) SizeVT() (n int) {
  5642  	if m == nil {
  5643  		return 0
  5644  	}
  5645  	var l int
  5646  	_ = l
  5647  	if len(m.Workflows) > 0 {
  5648  		for _, e := range m.Workflows {
  5649  			l = e.SizeVT()
  5650  			n += 1 + l + sov(uint64(l))
  5651  		}
  5652  	}
  5653  	if len(m.Warnings) > 0 {
  5654  		for _, s := range m.Warnings {
  5655  			l = len(s)
  5656  			n += 1 + l + sov(uint64(l))
  5657  		}
  5658  	}
  5659  	n += len(m.unknownFields)
  5660  	return n
  5661  }
  5662  
  5663  func (m *Keyspace) SizeVT() (n int) {
  5664  	if m == nil {
  5665  		return 0
  5666  	}
  5667  	var l int
  5668  	_ = l
  5669  	if m.Cluster != nil {
  5670  		l = m.Cluster.SizeVT()
  5671  		n += 1 + l + sov(uint64(l))
  5672  	}
  5673  	if m.Keyspace != nil {
  5674  		l = m.Keyspace.SizeVT()
  5675  		n += 1 + l + sov(uint64(l))
  5676  	}
  5677  	if len(m.Shards) > 0 {
  5678  		for k, v := range m.Shards {
  5679  			_ = k
  5680  			_ = v
  5681  			l = 0
  5682  			if v != nil {
  5683  				l = v.SizeVT()
  5684  			}
  5685  			l += 1 + sov(uint64(l))
  5686  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l
  5687  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  5688  		}
  5689  	}
  5690  	n += len(m.unknownFields)
  5691  	return n
  5692  }
  5693  
  5694  func (m *Schema_ShardTableSize) SizeVT() (n int) {
  5695  	if m == nil {
  5696  		return 0
  5697  	}
  5698  	var l int
  5699  	_ = l
  5700  	if m.RowCount != 0 {
  5701  		n += 1 + sov(uint64(m.RowCount))
  5702  	}
  5703  	if m.DataLength != 0 {
  5704  		n += 1 + sov(uint64(m.DataLength))
  5705  	}
  5706  	n += len(m.unknownFields)
  5707  	return n
  5708  }
  5709  
  5710  func (m *Schema_TableSize) SizeVT() (n int) {
  5711  	if m == nil {
  5712  		return 0
  5713  	}
  5714  	var l int
  5715  	_ = l
  5716  	if m.RowCount != 0 {
  5717  		n += 1 + sov(uint64(m.RowCount))
  5718  	}
  5719  	if m.DataLength != 0 {
  5720  		n += 1 + sov(uint64(m.DataLength))
  5721  	}
  5722  	if len(m.ByShard) > 0 {
  5723  		for k, v := range m.ByShard {
  5724  			_ = k
  5725  			_ = v
  5726  			l = 0
  5727  			if v != nil {
  5728  				l = v.SizeVT()
  5729  			}
  5730  			l += 1 + sov(uint64(l))
  5731  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l
  5732  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  5733  		}
  5734  	}
  5735  	n += len(m.unknownFields)
  5736  	return n
  5737  }
  5738  
  5739  func (m *Schema) SizeVT() (n int) {
  5740  	if m == nil {
  5741  		return 0
  5742  	}
  5743  	var l int
  5744  	_ = l
  5745  	if m.Cluster != nil {
  5746  		l = m.Cluster.SizeVT()
  5747  		n += 1 + l + sov(uint64(l))
  5748  	}
  5749  	l = len(m.Keyspace)
  5750  	if l > 0 {
  5751  		n += 1 + l + sov(uint64(l))
  5752  	}
  5753  	if len(m.TableDefinitions) > 0 {
  5754  		for _, e := range m.TableDefinitions {
  5755  			l = e.SizeVT()
  5756  			n += 1 + l + sov(uint64(l))
  5757  		}
  5758  	}
  5759  	if len(m.TableSizes) > 0 {
  5760  		for k, v := range m.TableSizes {
  5761  			_ = k
  5762  			_ = v
  5763  			l = 0
  5764  			if v != nil {
  5765  				l = v.SizeVT()
  5766  			}
  5767  			l += 1 + sov(uint64(l))
  5768  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l
  5769  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  5770  		}
  5771  	}
  5772  	n += len(m.unknownFields)
  5773  	return n
  5774  }
  5775  
  5776  func (m *Shard) SizeVT() (n int) {
  5777  	if m == nil {
  5778  		return 0
  5779  	}
  5780  	var l int
  5781  	_ = l
  5782  	if m.Cluster != nil {
  5783  		l = m.Cluster.SizeVT()
  5784  		n += 1 + l + sov(uint64(l))
  5785  	}
  5786  	if m.Shard != nil {
  5787  		l = m.Shard.SizeVT()
  5788  		n += 1 + l + sov(uint64(l))
  5789  	}
  5790  	n += len(m.unknownFields)
  5791  	return n
  5792  }
  5793  
  5794  func (m *SrvVSchema) SizeVT() (n int) {
  5795  	if m == nil {
  5796  		return 0
  5797  	}
  5798  	var l int
  5799  	_ = l
  5800  	l = len(m.Cell)
  5801  	if l > 0 {
  5802  		n += 1 + l + sov(uint64(l))
  5803  	}
  5804  	if m.Cluster != nil {
  5805  		l = m.Cluster.SizeVT()
  5806  		n += 1 + l + sov(uint64(l))
  5807  	}
  5808  	if m.SrvVSchema != nil {
  5809  		l = m.SrvVSchema.SizeVT()
  5810  		n += 1 + l + sov(uint64(l))
  5811  	}
  5812  	n += len(m.unknownFields)
  5813  	return n
  5814  }
  5815  
  5816  func (m *Tablet) SizeVT() (n int) {
  5817  	if m == nil {
  5818  		return 0
  5819  	}
  5820  	var l int
  5821  	_ = l
  5822  	if m.Cluster != nil {
  5823  		l = m.Cluster.SizeVT()
  5824  		n += 1 + l + sov(uint64(l))
  5825  	}
  5826  	if m.Tablet != nil {
  5827  		l = m.Tablet.SizeVT()
  5828  		n += 1 + l + sov(uint64(l))
  5829  	}
  5830  	if m.State != 0 {
  5831  		n += 1 + sov(uint64(m.State))
  5832  	}
  5833  	l = len(m.FQDN)
  5834  	if l > 0 {
  5835  		n += 1 + l + sov(uint64(l))
  5836  	}
  5837  	n += len(m.unknownFields)
  5838  	return n
  5839  }
  5840  
  5841  func (m *VSchema) SizeVT() (n int) {
  5842  	if m == nil {
  5843  		return 0
  5844  	}
  5845  	var l int
  5846  	_ = l
  5847  	if m.Cluster != nil {
  5848  		l = m.Cluster.SizeVT()
  5849  		n += 1 + l + sov(uint64(l))
  5850  	}
  5851  	l = len(m.Name)
  5852  	if l > 0 {
  5853  		n += 1 + l + sov(uint64(l))
  5854  	}
  5855  	if m.VSchema != nil {
  5856  		l = m.VSchema.SizeVT()
  5857  		n += 1 + l + sov(uint64(l))
  5858  	}
  5859  	n += len(m.unknownFields)
  5860  	return n
  5861  }
  5862  
  5863  func (m *Vtctld) SizeVT() (n int) {
  5864  	if m == nil {
  5865  		return 0
  5866  	}
  5867  	var l int
  5868  	_ = l
  5869  	l = len(m.Hostname)
  5870  	if l > 0 {
  5871  		n += 1 + l + sov(uint64(l))
  5872  	}
  5873  	if m.Cluster != nil {
  5874  		l = m.Cluster.SizeVT()
  5875  		n += 1 + l + sov(uint64(l))
  5876  	}
  5877  	l = len(m.FQDN)
  5878  	if l > 0 {
  5879  		n += 1 + l + sov(uint64(l))
  5880  	}
  5881  	n += len(m.unknownFields)
  5882  	return n
  5883  }
  5884  
  5885  func (m *VTGate) SizeVT() (n int) {
  5886  	if m == nil {
  5887  		return 0
  5888  	}
  5889  	var l int
  5890  	_ = l
  5891  	l = len(m.Hostname)
  5892  	if l > 0 {
  5893  		n += 1 + l + sov(uint64(l))
  5894  	}
  5895  	l = len(m.Pool)
  5896  	if l > 0 {
  5897  		n += 1 + l + sov(uint64(l))
  5898  	}
  5899  	l = len(m.Cell)
  5900  	if l > 0 {
  5901  		n += 1 + l + sov(uint64(l))
  5902  	}
  5903  	if m.Cluster != nil {
  5904  		l = m.Cluster.SizeVT()
  5905  		n += 1 + l + sov(uint64(l))
  5906  	}
  5907  	if len(m.Keyspaces) > 0 {
  5908  		for _, s := range m.Keyspaces {
  5909  			l = len(s)
  5910  			n += 1 + l + sov(uint64(l))
  5911  		}
  5912  	}
  5913  	l = len(m.FQDN)
  5914  	if l > 0 {
  5915  		n += 1 + l + sov(uint64(l))
  5916  	}
  5917  	n += len(m.unknownFields)
  5918  	return n
  5919  }
  5920  
  5921  func (m *Workflow) SizeVT() (n int) {
  5922  	if m == nil {
  5923  		return 0
  5924  	}
  5925  	var l int
  5926  	_ = l
  5927  	if m.Cluster != nil {
  5928  		l = m.Cluster.SizeVT()
  5929  		n += 1 + l + sov(uint64(l))
  5930  	}
  5931  	l = len(m.Keyspace)
  5932  	if l > 0 {
  5933  		n += 1 + l + sov(uint64(l))
  5934  	}
  5935  	if m.Workflow != nil {
  5936  		l = m.Workflow.SizeVT()
  5937  		n += 1 + l + sov(uint64(l))
  5938  	}
  5939  	n += len(m.unknownFields)
  5940  	return n
  5941  }
  5942  
  5943  func (m *CreateKeyspaceRequest) SizeVT() (n int) {
  5944  	if m == nil {
  5945  		return 0
  5946  	}
  5947  	var l int
  5948  	_ = l
  5949  	l = len(m.ClusterId)
  5950  	if l > 0 {
  5951  		n += 1 + l + sov(uint64(l))
  5952  	}
  5953  	if m.Options != nil {
  5954  		l = m.Options.SizeVT()
  5955  		n += 1 + l + sov(uint64(l))
  5956  	}
  5957  	n += len(m.unknownFields)
  5958  	return n
  5959  }
  5960  
  5961  func (m *CreateKeyspaceResponse) SizeVT() (n int) {
  5962  	if m == nil {
  5963  		return 0
  5964  	}
  5965  	var l int
  5966  	_ = l
  5967  	if m.Keyspace != nil {
  5968  		l = m.Keyspace.SizeVT()
  5969  		n += 1 + l + sov(uint64(l))
  5970  	}
  5971  	n += len(m.unknownFields)
  5972  	return n
  5973  }
  5974  
  5975  func (m *CreateShardRequest) SizeVT() (n int) {
  5976  	if m == nil {
  5977  		return 0
  5978  	}
  5979  	var l int
  5980  	_ = l
  5981  	l = len(m.ClusterId)
  5982  	if l > 0 {
  5983  		n += 1 + l + sov(uint64(l))
  5984  	}
  5985  	if m.Options != nil {
  5986  		l = m.Options.SizeVT()
  5987  		n += 1 + l + sov(uint64(l))
  5988  	}
  5989  	n += len(m.unknownFields)
  5990  	return n
  5991  }
  5992  
  5993  func (m *DeleteKeyspaceRequest) SizeVT() (n int) {
  5994  	if m == nil {
  5995  		return 0
  5996  	}
  5997  	var l int
  5998  	_ = l
  5999  	l = len(m.ClusterId)
  6000  	if l > 0 {
  6001  		n += 1 + l + sov(uint64(l))
  6002  	}
  6003  	if m.Options != nil {
  6004  		l = m.Options.SizeVT()
  6005  		n += 1 + l + sov(uint64(l))
  6006  	}
  6007  	n += len(m.unknownFields)
  6008  	return n
  6009  }
  6010  
  6011  func (m *DeleteShardsRequest) SizeVT() (n int) {
  6012  	if m == nil {
  6013  		return 0
  6014  	}
  6015  	var l int
  6016  	_ = l
  6017  	l = len(m.ClusterId)
  6018  	if l > 0 {
  6019  		n += 1 + l + sov(uint64(l))
  6020  	}
  6021  	if m.Options != nil {
  6022  		l = m.Options.SizeVT()
  6023  		n += 1 + l + sov(uint64(l))
  6024  	}
  6025  	n += len(m.unknownFields)
  6026  	return n
  6027  }
  6028  
  6029  func (m *DeleteTabletRequest) SizeVT() (n int) {
  6030  	if m == nil {
  6031  		return 0
  6032  	}
  6033  	var l int
  6034  	_ = l
  6035  	if m.Alias != nil {
  6036  		l = m.Alias.SizeVT()
  6037  		n += 1 + l + sov(uint64(l))
  6038  	}
  6039  	if len(m.ClusterIds) > 0 {
  6040  		for _, s := range m.ClusterIds {
  6041  			l = len(s)
  6042  			n += 1 + l + sov(uint64(l))
  6043  		}
  6044  	}
  6045  	if m.AllowPrimary {
  6046  		n += 2
  6047  	}
  6048  	n += len(m.unknownFields)
  6049  	return n
  6050  }
  6051  
  6052  func (m *DeleteTabletResponse) SizeVT() (n int) {
  6053  	if m == nil {
  6054  		return 0
  6055  	}
  6056  	var l int
  6057  	_ = l
  6058  	l = len(m.Status)
  6059  	if l > 0 {
  6060  		n += 1 + l + sov(uint64(l))
  6061  	}
  6062  	if m.Cluster != nil {
  6063  		l = m.Cluster.SizeVT()
  6064  		n += 1 + l + sov(uint64(l))
  6065  	}
  6066  	n += len(m.unknownFields)
  6067  	return n
  6068  }
  6069  
  6070  func (m *EmergencyFailoverShardRequest) SizeVT() (n int) {
  6071  	if m == nil {
  6072  		return 0
  6073  	}
  6074  	var l int
  6075  	_ = l
  6076  	l = len(m.ClusterId)
  6077  	if l > 0 {
  6078  		n += 1 + l + sov(uint64(l))
  6079  	}
  6080  	if m.Options != nil {
  6081  		l = m.Options.SizeVT()
  6082  		n += 1 + l + sov(uint64(l))
  6083  	}
  6084  	n += len(m.unknownFields)
  6085  	return n
  6086  }
  6087  
  6088  func (m *EmergencyFailoverShardResponse) SizeVT() (n int) {
  6089  	if m == nil {
  6090  		return 0
  6091  	}
  6092  	var l int
  6093  	_ = l
  6094  	if m.Cluster != nil {
  6095  		l = m.Cluster.SizeVT()
  6096  		n += 1 + l + sov(uint64(l))
  6097  	}
  6098  	l = len(m.Keyspace)
  6099  	if l > 0 {
  6100  		n += 1 + l + sov(uint64(l))
  6101  	}
  6102  	l = len(m.Shard)
  6103  	if l > 0 {
  6104  		n += 1 + l + sov(uint64(l))
  6105  	}
  6106  	if m.PromotedPrimary != nil {
  6107  		l = m.PromotedPrimary.SizeVT()
  6108  		n += 1 + l + sov(uint64(l))
  6109  	}
  6110  	if len(m.Events) > 0 {
  6111  		for _, e := range m.Events {
  6112  			l = e.SizeVT()
  6113  			n += 1 + l + sov(uint64(l))
  6114  		}
  6115  	}
  6116  	n += len(m.unknownFields)
  6117  	return n
  6118  }
  6119  
  6120  func (m *FindSchemaRequest) SizeVT() (n int) {
  6121  	if m == nil {
  6122  		return 0
  6123  	}
  6124  	var l int
  6125  	_ = l
  6126  	l = len(m.Table)
  6127  	if l > 0 {
  6128  		n += 1 + l + sov(uint64(l))
  6129  	}
  6130  	if len(m.ClusterIds) > 0 {
  6131  		for _, s := range m.ClusterIds {
  6132  			l = len(s)
  6133  			n += 1 + l + sov(uint64(l))
  6134  		}
  6135  	}
  6136  	if m.TableSizeOptions != nil {
  6137  		l = m.TableSizeOptions.SizeVT()
  6138  		n += 1 + l + sov(uint64(l))
  6139  	}
  6140  	n += len(m.unknownFields)
  6141  	return n
  6142  }
  6143  
  6144  func (m *GetBackupsRequest) SizeVT() (n int) {
  6145  	if m == nil {
  6146  		return 0
  6147  	}
  6148  	var l int
  6149  	_ = l
  6150  	if len(m.ClusterIds) > 0 {
  6151  		for _, s := range m.ClusterIds {
  6152  			l = len(s)
  6153  			n += 1 + l + sov(uint64(l))
  6154  		}
  6155  	}
  6156  	if len(m.Keyspaces) > 0 {
  6157  		for _, s := range m.Keyspaces {
  6158  			l = len(s)
  6159  			n += 1 + l + sov(uint64(l))
  6160  		}
  6161  	}
  6162  	if len(m.KeyspaceShards) > 0 {
  6163  		for _, s := range m.KeyspaceShards {
  6164  			l = len(s)
  6165  			n += 1 + l + sov(uint64(l))
  6166  		}
  6167  	}
  6168  	if m.RequestOptions != nil {
  6169  		l = m.RequestOptions.SizeVT()
  6170  		n += 1 + l + sov(uint64(l))
  6171  	}
  6172  	n += len(m.unknownFields)
  6173  	return n
  6174  }
  6175  
  6176  func (m *GetBackupsResponse) SizeVT() (n int) {
  6177  	if m == nil {
  6178  		return 0
  6179  	}
  6180  	var l int
  6181  	_ = l
  6182  	if len(m.Backups) > 0 {
  6183  		for _, e := range m.Backups {
  6184  			l = e.SizeVT()
  6185  			n += 1 + l + sov(uint64(l))
  6186  		}
  6187  	}
  6188  	n += len(m.unknownFields)
  6189  	return n
  6190  }
  6191  
  6192  func (m *GetCellInfosRequest) SizeVT() (n int) {
  6193  	if m == nil {
  6194  		return 0
  6195  	}
  6196  	var l int
  6197  	_ = l
  6198  	if len(m.ClusterIds) > 0 {
  6199  		for _, s := range m.ClusterIds {
  6200  			l = len(s)
  6201  			n += 1 + l + sov(uint64(l))
  6202  		}
  6203  	}
  6204  	if len(m.Cells) > 0 {
  6205  		for _, s := range m.Cells {
  6206  			l = len(s)
  6207  			n += 1 + l + sov(uint64(l))
  6208  		}
  6209  	}
  6210  	if m.NamesOnly {
  6211  		n += 2
  6212  	}
  6213  	n += len(m.unknownFields)
  6214  	return n
  6215  }
  6216  
  6217  func (m *GetCellInfosResponse) SizeVT() (n int) {
  6218  	if m == nil {
  6219  		return 0
  6220  	}
  6221  	var l int
  6222  	_ = l
  6223  	if len(m.CellInfos) > 0 {
  6224  		for _, e := range m.CellInfos {
  6225  			l = e.SizeVT()
  6226  			n += 1 + l + sov(uint64(l))
  6227  		}
  6228  	}
  6229  	n += len(m.unknownFields)
  6230  	return n
  6231  }
  6232  
  6233  func (m *GetCellsAliasesRequest) SizeVT() (n int) {
  6234  	if m == nil {
  6235  		return 0
  6236  	}
  6237  	var l int
  6238  	_ = l
  6239  	if len(m.ClusterIds) > 0 {
  6240  		for _, s := range m.ClusterIds {
  6241  			l = len(s)
  6242  			n += 1 + l + sov(uint64(l))
  6243  		}
  6244  	}
  6245  	n += len(m.unknownFields)
  6246  	return n
  6247  }
  6248  
  6249  func (m *GetCellsAliasesResponse) SizeVT() (n int) {
  6250  	if m == nil {
  6251  		return 0
  6252  	}
  6253  	var l int
  6254  	_ = l
  6255  	if len(m.Aliases) > 0 {
  6256  		for _, e := range m.Aliases {
  6257  			l = e.SizeVT()
  6258  			n += 1 + l + sov(uint64(l))
  6259  		}
  6260  	}
  6261  	n += len(m.unknownFields)
  6262  	return n
  6263  }
  6264  
  6265  func (m *GetClustersRequest) SizeVT() (n int) {
  6266  	if m == nil {
  6267  		return 0
  6268  	}
  6269  	var l int
  6270  	_ = l
  6271  	n += len(m.unknownFields)
  6272  	return n
  6273  }
  6274  
  6275  func (m *GetClustersResponse) SizeVT() (n int) {
  6276  	if m == nil {
  6277  		return 0
  6278  	}
  6279  	var l int
  6280  	_ = l
  6281  	if len(m.Clusters) > 0 {
  6282  		for _, e := range m.Clusters {
  6283  			l = e.SizeVT()
  6284  			n += 1 + l + sov(uint64(l))
  6285  		}
  6286  	}
  6287  	n += len(m.unknownFields)
  6288  	return n
  6289  }
  6290  
  6291  func (m *GetFullStatusRequest) SizeVT() (n int) {
  6292  	if m == nil {
  6293  		return 0
  6294  	}
  6295  	var l int
  6296  	_ = l
  6297  	l = len(m.ClusterId)
  6298  	if l > 0 {
  6299  		n += 1 + l + sov(uint64(l))
  6300  	}
  6301  	if m.Alias != nil {
  6302  		l = m.Alias.SizeVT()
  6303  		n += 1 + l + sov(uint64(l))
  6304  	}
  6305  	n += len(m.unknownFields)
  6306  	return n
  6307  }
  6308  
  6309  func (m *GetGatesRequest) SizeVT() (n int) {
  6310  	if m == nil {
  6311  		return 0
  6312  	}
  6313  	var l int
  6314  	_ = l
  6315  	if len(m.ClusterIds) > 0 {
  6316  		for _, s := range m.ClusterIds {
  6317  			l = len(s)
  6318  			n += 1 + l + sov(uint64(l))
  6319  		}
  6320  	}
  6321  	n += len(m.unknownFields)
  6322  	return n
  6323  }
  6324  
  6325  func (m *GetGatesResponse) SizeVT() (n int) {
  6326  	if m == nil {
  6327  		return 0
  6328  	}
  6329  	var l int
  6330  	_ = l
  6331  	if len(m.Gates) > 0 {
  6332  		for _, e := range m.Gates {
  6333  			l = e.SizeVT()
  6334  			n += 1 + l + sov(uint64(l))
  6335  		}
  6336  	}
  6337  	n += len(m.unknownFields)
  6338  	return n
  6339  }
  6340  
  6341  func (m *GetKeyspaceRequest) SizeVT() (n int) {
  6342  	if m == nil {
  6343  		return 0
  6344  	}
  6345  	var l int
  6346  	_ = l
  6347  	l = len(m.ClusterId)
  6348  	if l > 0 {
  6349  		n += 1 + l + sov(uint64(l))
  6350  	}
  6351  	l = len(m.Keyspace)
  6352  	if l > 0 {
  6353  		n += 1 + l + sov(uint64(l))
  6354  	}
  6355  	n += len(m.unknownFields)
  6356  	return n
  6357  }
  6358  
  6359  func (m *GetKeyspacesRequest) SizeVT() (n int) {
  6360  	if m == nil {
  6361  		return 0
  6362  	}
  6363  	var l int
  6364  	_ = l
  6365  	if len(m.ClusterIds) > 0 {
  6366  		for _, s := range m.ClusterIds {
  6367  			l = len(s)
  6368  			n += 1 + l + sov(uint64(l))
  6369  		}
  6370  	}
  6371  	n += len(m.unknownFields)
  6372  	return n
  6373  }
  6374  
  6375  func (m *GetKeyspacesResponse) SizeVT() (n int) {
  6376  	if m == nil {
  6377  		return 0
  6378  	}
  6379  	var l int
  6380  	_ = l
  6381  	if len(m.Keyspaces) > 0 {
  6382  		for _, e := range m.Keyspaces {
  6383  			l = e.SizeVT()
  6384  			n += 1 + l + sov(uint64(l))
  6385  		}
  6386  	}
  6387  	n += len(m.unknownFields)
  6388  	return n
  6389  }
  6390  
  6391  func (m *GetSchemaRequest) SizeVT() (n int) {
  6392  	if m == nil {
  6393  		return 0
  6394  	}
  6395  	var l int
  6396  	_ = l
  6397  	l = len(m.ClusterId)
  6398  	if l > 0 {
  6399  		n += 1 + l + sov(uint64(l))
  6400  	}
  6401  	l = len(m.Keyspace)
  6402  	if l > 0 {
  6403  		n += 1 + l + sov(uint64(l))
  6404  	}
  6405  	l = len(m.Table)
  6406  	if l > 0 {
  6407  		n += 1 + l + sov(uint64(l))
  6408  	}
  6409  	if m.TableSizeOptions != nil {
  6410  		l = m.TableSizeOptions.SizeVT()
  6411  		n += 1 + l + sov(uint64(l))
  6412  	}
  6413  	n += len(m.unknownFields)
  6414  	return n
  6415  }
  6416  
  6417  func (m *GetSchemasRequest) SizeVT() (n int) {
  6418  	if m == nil {
  6419  		return 0
  6420  	}
  6421  	var l int
  6422  	_ = l
  6423  	if len(m.ClusterIds) > 0 {
  6424  		for _, s := range m.ClusterIds {
  6425  			l = len(s)
  6426  			n += 1 + l + sov(uint64(l))
  6427  		}
  6428  	}
  6429  	if m.TableSizeOptions != nil {
  6430  		l = m.TableSizeOptions.SizeVT()
  6431  		n += 1 + l + sov(uint64(l))
  6432  	}
  6433  	n += len(m.unknownFields)
  6434  	return n
  6435  }
  6436  
  6437  func (m *GetSchemasResponse) SizeVT() (n int) {
  6438  	if m == nil {
  6439  		return 0
  6440  	}
  6441  	var l int
  6442  	_ = l
  6443  	if len(m.Schemas) > 0 {
  6444  		for _, e := range m.Schemas {
  6445  			l = e.SizeVT()
  6446  			n += 1 + l + sov(uint64(l))
  6447  		}
  6448  	}
  6449  	n += len(m.unknownFields)
  6450  	return n
  6451  }
  6452  
  6453  func (m *GetShardReplicationPositionsRequest) SizeVT() (n int) {
  6454  	if m == nil {
  6455  		return 0
  6456  	}
  6457  	var l int
  6458  	_ = l
  6459  	if len(m.ClusterIds) > 0 {
  6460  		for _, s := range m.ClusterIds {
  6461  			l = len(s)
  6462  			n += 1 + l + sov(uint64(l))
  6463  		}
  6464  	}
  6465  	if len(m.Keyspaces) > 0 {
  6466  		for _, s := range m.Keyspaces {
  6467  			l = len(s)
  6468  			n += 1 + l + sov(uint64(l))
  6469  		}
  6470  	}
  6471  	if len(m.KeyspaceShards) > 0 {
  6472  		for _, s := range m.KeyspaceShards {
  6473  			l = len(s)
  6474  			n += 1 + l + sov(uint64(l))
  6475  		}
  6476  	}
  6477  	n += len(m.unknownFields)
  6478  	return n
  6479  }
  6480  
  6481  func (m *GetShardReplicationPositionsResponse) SizeVT() (n int) {
  6482  	if m == nil {
  6483  		return 0
  6484  	}
  6485  	var l int
  6486  	_ = l
  6487  	if len(m.ReplicationPositions) > 0 {
  6488  		for _, e := range m.ReplicationPositions {
  6489  			l = e.SizeVT()
  6490  			n += 1 + l + sov(uint64(l))
  6491  		}
  6492  	}
  6493  	n += len(m.unknownFields)
  6494  	return n
  6495  }
  6496  
  6497  func (m *GetSrvVSchemaRequest) SizeVT() (n int) {
  6498  	if m == nil {
  6499  		return 0
  6500  	}
  6501  	var l int
  6502  	_ = l
  6503  	l = len(m.ClusterId)
  6504  	if l > 0 {
  6505  		n += 1 + l + sov(uint64(l))
  6506  	}
  6507  	l = len(m.Cell)
  6508  	if l > 0 {
  6509  		n += 1 + l + sov(uint64(l))
  6510  	}
  6511  	n += len(m.unknownFields)
  6512  	return n
  6513  }
  6514  
  6515  func (m *GetSrvVSchemasRequest) SizeVT() (n int) {
  6516  	if m == nil {
  6517  		return 0
  6518  	}
  6519  	var l int
  6520  	_ = l
  6521  	if len(m.ClusterIds) > 0 {
  6522  		for _, s := range m.ClusterIds {
  6523  			l = len(s)
  6524  			n += 1 + l + sov(uint64(l))
  6525  		}
  6526  	}
  6527  	if len(m.Cells) > 0 {
  6528  		for _, s := range m.Cells {
  6529  			l = len(s)
  6530  			n += 1 + l + sov(uint64(l))
  6531  		}
  6532  	}
  6533  	n += len(m.unknownFields)
  6534  	return n
  6535  }
  6536  
  6537  func (m *GetSrvVSchemasResponse) SizeVT() (n int) {
  6538  	if m == nil {
  6539  		return 0
  6540  	}
  6541  	var l int
  6542  	_ = l
  6543  	if len(m.SrvVSchemas) > 0 {
  6544  		for _, e := range m.SrvVSchemas {
  6545  			l = e.SizeVT()
  6546  			n += 1 + l + sov(uint64(l))
  6547  		}
  6548  	}
  6549  	n += len(m.unknownFields)
  6550  	return n
  6551  }
  6552  
  6553  func (m *GetSchemaTableSizeOptions) SizeVT() (n int) {
  6554  	if m == nil {
  6555  		return 0
  6556  	}
  6557  	var l int
  6558  	_ = l
  6559  	if m.AggregateSizes {
  6560  		n += 2
  6561  	}
  6562  	if m.IncludeNonServingShards {
  6563  		n += 2
  6564  	}
  6565  	n += len(m.unknownFields)
  6566  	return n
  6567  }
  6568  
  6569  func (m *GetTabletRequest) SizeVT() (n int) {
  6570  	if m == nil {
  6571  		return 0
  6572  	}
  6573  	var l int
  6574  	_ = l
  6575  	if m.Alias != nil {
  6576  		l = m.Alias.SizeVT()
  6577  		n += 1 + l + sov(uint64(l))
  6578  	}
  6579  	if len(m.ClusterIds) > 0 {
  6580  		for _, s := range m.ClusterIds {
  6581  			l = len(s)
  6582  			n += 1 + l + sov(uint64(l))
  6583  		}
  6584  	}
  6585  	n += len(m.unknownFields)
  6586  	return n
  6587  }
  6588  
  6589  func (m *GetTabletsRequest) SizeVT() (n int) {
  6590  	if m == nil {
  6591  		return 0
  6592  	}
  6593  	var l int
  6594  	_ = l
  6595  	if len(m.ClusterIds) > 0 {
  6596  		for _, s := range m.ClusterIds {
  6597  			l = len(s)
  6598  			n += 1 + l + sov(uint64(l))
  6599  		}
  6600  	}
  6601  	n += len(m.unknownFields)
  6602  	return n
  6603  }
  6604  
  6605  func (m *GetTabletsResponse) SizeVT() (n int) {
  6606  	if m == nil {
  6607  		return 0
  6608  	}
  6609  	var l int
  6610  	_ = l
  6611  	if len(m.Tablets) > 0 {
  6612  		for _, e := range m.Tablets {
  6613  			l = e.SizeVT()
  6614  			n += 1 + l + sov(uint64(l))
  6615  		}
  6616  	}
  6617  	n += len(m.unknownFields)
  6618  	return n
  6619  }
  6620  
  6621  func (m *GetTopologyPathRequest) SizeVT() (n int) {
  6622  	if m == nil {
  6623  		return 0
  6624  	}
  6625  	var l int
  6626  	_ = l
  6627  	l = len(m.ClusterId)
  6628  	if l > 0 {
  6629  		n += 1 + l + sov(uint64(l))
  6630  	}
  6631  	l = len(m.Path)
  6632  	if l > 0 {
  6633  		n += 1 + l + sov(uint64(l))
  6634  	}
  6635  	n += len(m.unknownFields)
  6636  	return n
  6637  }
  6638  
  6639  func (m *GetVSchemaRequest) SizeVT() (n int) {
  6640  	if m == nil {
  6641  		return 0
  6642  	}
  6643  	var l int
  6644  	_ = l
  6645  	l = len(m.ClusterId)
  6646  	if l > 0 {
  6647  		n += 1 + l + sov(uint64(l))
  6648  	}
  6649  	l = len(m.Keyspace)
  6650  	if l > 0 {
  6651  		n += 1 + l + sov(uint64(l))
  6652  	}
  6653  	n += len(m.unknownFields)
  6654  	return n
  6655  }
  6656  
  6657  func (m *GetVSchemasRequest) SizeVT() (n int) {
  6658  	if m == nil {
  6659  		return 0
  6660  	}
  6661  	var l int
  6662  	_ = l
  6663  	if len(m.ClusterIds) > 0 {
  6664  		for _, s := range m.ClusterIds {
  6665  			l = len(s)
  6666  			n += 1 + l + sov(uint64(l))
  6667  		}
  6668  	}
  6669  	n += len(m.unknownFields)
  6670  	return n
  6671  }
  6672  
  6673  func (m *GetVSchemasResponse) SizeVT() (n int) {
  6674  	if m == nil {
  6675  		return 0
  6676  	}
  6677  	var l int
  6678  	_ = l
  6679  	if len(m.VSchemas) > 0 {
  6680  		for _, e := range m.VSchemas {
  6681  			l = e.SizeVT()
  6682  			n += 1 + l + sov(uint64(l))
  6683  		}
  6684  	}
  6685  	n += len(m.unknownFields)
  6686  	return n
  6687  }
  6688  
  6689  func (m *GetVtctldsRequest) SizeVT() (n int) {
  6690  	if m == nil {
  6691  		return 0
  6692  	}
  6693  	var l int
  6694  	_ = l
  6695  	if len(m.ClusterIds) > 0 {
  6696  		for _, s := range m.ClusterIds {
  6697  			l = len(s)
  6698  			n += 1 + l + sov(uint64(l))
  6699  		}
  6700  	}
  6701  	n += len(m.unknownFields)
  6702  	return n
  6703  }
  6704  
  6705  func (m *GetVtctldsResponse) SizeVT() (n int) {
  6706  	if m == nil {
  6707  		return 0
  6708  	}
  6709  	var l int
  6710  	_ = l
  6711  	if len(m.Vtctlds) > 0 {
  6712  		for _, e := range m.Vtctlds {
  6713  			l = e.SizeVT()
  6714  			n += 1 + l + sov(uint64(l))
  6715  		}
  6716  	}
  6717  	n += len(m.unknownFields)
  6718  	return n
  6719  }
  6720  
  6721  func (m *GetWorkflowRequest) SizeVT() (n int) {
  6722  	if m == nil {
  6723  		return 0
  6724  	}
  6725  	var l int
  6726  	_ = l
  6727  	l = len(m.ClusterId)
  6728  	if l > 0 {
  6729  		n += 1 + l + sov(uint64(l))
  6730  	}
  6731  	l = len(m.Keyspace)
  6732  	if l > 0 {
  6733  		n += 1 + l + sov(uint64(l))
  6734  	}
  6735  	l = len(m.Name)
  6736  	if l > 0 {
  6737  		n += 1 + l + sov(uint64(l))
  6738  	}
  6739  	if m.ActiveOnly {
  6740  		n += 2
  6741  	}
  6742  	n += len(m.unknownFields)
  6743  	return n
  6744  }
  6745  
  6746  func (m *GetWorkflowsRequest) SizeVT() (n int) {
  6747  	if m == nil {
  6748  		return 0
  6749  	}
  6750  	var l int
  6751  	_ = l
  6752  	if len(m.ClusterIds) > 0 {
  6753  		for _, s := range m.ClusterIds {
  6754  			l = len(s)
  6755  			n += 1 + l + sov(uint64(l))
  6756  		}
  6757  	}
  6758  	if m.ActiveOnly {
  6759  		n += 2
  6760  	}
  6761  	if len(m.Keyspaces) > 0 {
  6762  		for _, s := range m.Keyspaces {
  6763  			l = len(s)
  6764  			n += 1 + l + sov(uint64(l))
  6765  		}
  6766  	}
  6767  	if len(m.IgnoreKeyspaces) > 0 {
  6768  		for _, s := range m.IgnoreKeyspaces {
  6769  			l = len(s)
  6770  			n += 1 + l + sov(uint64(l))
  6771  		}
  6772  	}
  6773  	n += len(m.unknownFields)
  6774  	return n
  6775  }
  6776  
  6777  func (m *GetWorkflowsResponse) SizeVT() (n int) {
  6778  	if m == nil {
  6779  		return 0
  6780  	}
  6781  	var l int
  6782  	_ = l
  6783  	if len(m.WorkflowsByCluster) > 0 {
  6784  		for k, v := range m.WorkflowsByCluster {
  6785  			_ = k
  6786  			_ = v
  6787  			l = 0
  6788  			if v != nil {
  6789  				l = v.SizeVT()
  6790  			}
  6791  			l += 1 + sov(uint64(l))
  6792  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l
  6793  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  6794  		}
  6795  	}
  6796  	n += len(m.unknownFields)
  6797  	return n
  6798  }
  6799  
  6800  func (m *PingTabletRequest) SizeVT() (n int) {
  6801  	if m == nil {
  6802  		return 0
  6803  	}
  6804  	var l int
  6805  	_ = l
  6806  	if m.Alias != nil {
  6807  		l = m.Alias.SizeVT()
  6808  		n += 1 + l + sov(uint64(l))
  6809  	}
  6810  	if len(m.ClusterIds) > 0 {
  6811  		for _, s := range m.ClusterIds {
  6812  			l = len(s)
  6813  			n += 1 + l + sov(uint64(l))
  6814  		}
  6815  	}
  6816  	n += len(m.unknownFields)
  6817  	return n
  6818  }
  6819  
  6820  func (m *PingTabletResponse) SizeVT() (n int) {
  6821  	if m == nil {
  6822  		return 0
  6823  	}
  6824  	var l int
  6825  	_ = l
  6826  	l = len(m.Status)
  6827  	if l > 0 {
  6828  		n += 1 + l + sov(uint64(l))
  6829  	}
  6830  	if m.Cluster != nil {
  6831  		l = m.Cluster.SizeVT()
  6832  		n += 1 + l + sov(uint64(l))
  6833  	}
  6834  	n += len(m.unknownFields)
  6835  	return n
  6836  }
  6837  
  6838  func (m *PlannedFailoverShardRequest) SizeVT() (n int) {
  6839  	if m == nil {
  6840  		return 0
  6841  	}
  6842  	var l int
  6843  	_ = l
  6844  	l = len(m.ClusterId)
  6845  	if l > 0 {
  6846  		n += 1 + l + sov(uint64(l))
  6847  	}
  6848  	if m.Options != nil {
  6849  		l = m.Options.SizeVT()
  6850  		n += 1 + l + sov(uint64(l))
  6851  	}
  6852  	n += len(m.unknownFields)
  6853  	return n
  6854  }
  6855  
  6856  func (m *PlannedFailoverShardResponse) SizeVT() (n int) {
  6857  	if m == nil {
  6858  		return 0
  6859  	}
  6860  	var l int
  6861  	_ = l
  6862  	if m.Cluster != nil {
  6863  		l = m.Cluster.SizeVT()
  6864  		n += 1 + l + sov(uint64(l))
  6865  	}
  6866  	l = len(m.Keyspace)
  6867  	if l > 0 {
  6868  		n += 1 + l + sov(uint64(l))
  6869  	}
  6870  	l = len(m.Shard)
  6871  	if l > 0 {
  6872  		n += 1 + l + sov(uint64(l))
  6873  	}
  6874  	if m.PromotedPrimary != nil {
  6875  		l = m.PromotedPrimary.SizeVT()
  6876  		n += 1 + l + sov(uint64(l))
  6877  	}
  6878  	if len(m.Events) > 0 {
  6879  		for _, e := range m.Events {
  6880  			l = e.SizeVT()
  6881  			n += 1 + l + sov(uint64(l))
  6882  		}
  6883  	}
  6884  	n += len(m.unknownFields)
  6885  	return n
  6886  }
  6887  
  6888  func (m *RebuildKeyspaceGraphRequest) SizeVT() (n int) {
  6889  	if m == nil {
  6890  		return 0
  6891  	}
  6892  	var l int
  6893  	_ = l
  6894  	l = len(m.ClusterId)
  6895  	if l > 0 {
  6896  		n += 1 + l + sov(uint64(l))
  6897  	}
  6898  	l = len(m.Keyspace)
  6899  	if l > 0 {
  6900  		n += 1 + l + sov(uint64(l))
  6901  	}
  6902  	if len(m.Cells) > 0 {
  6903  		for _, s := range m.Cells {
  6904  			l = len(s)
  6905  			n += 1 + l + sov(uint64(l))
  6906  		}
  6907  	}
  6908  	if m.AllowPartial {
  6909  		n += 2
  6910  	}
  6911  	n += len(m.unknownFields)
  6912  	return n
  6913  }
  6914  
  6915  func (m *RebuildKeyspaceGraphResponse) SizeVT() (n int) {
  6916  	if m == nil {
  6917  		return 0
  6918  	}
  6919  	var l int
  6920  	_ = l
  6921  	l = len(m.Status)
  6922  	if l > 0 {
  6923  		n += 1 + l + sov(uint64(l))
  6924  	}
  6925  	n += len(m.unknownFields)
  6926  	return n
  6927  }
  6928  
  6929  func (m *RefreshStateRequest) SizeVT() (n int) {
  6930  	if m == nil {
  6931  		return 0
  6932  	}
  6933  	var l int
  6934  	_ = l
  6935  	if m.Alias != nil {
  6936  		l = m.Alias.SizeVT()
  6937  		n += 1 + l + sov(uint64(l))
  6938  	}
  6939  	if len(m.ClusterIds) > 0 {
  6940  		for _, s := range m.ClusterIds {
  6941  			l = len(s)
  6942  			n += 1 + l + sov(uint64(l))
  6943  		}
  6944  	}
  6945  	n += len(m.unknownFields)
  6946  	return n
  6947  }
  6948  
  6949  func (m *RefreshStateResponse) SizeVT() (n int) {
  6950  	if m == nil {
  6951  		return 0
  6952  	}
  6953  	var l int
  6954  	_ = l
  6955  	l = len(m.Status)
  6956  	if l > 0 {
  6957  		n += 1 + l + sov(uint64(l))
  6958  	}
  6959  	if m.Cluster != nil {
  6960  		l = m.Cluster.SizeVT()
  6961  		n += 1 + l + sov(uint64(l))
  6962  	}
  6963  	n += len(m.unknownFields)
  6964  	return n
  6965  }
  6966  
  6967  func (m *ReloadSchemasRequest) SizeVT() (n int) {
  6968  	if m == nil {
  6969  		return 0
  6970  	}
  6971  	var l int
  6972  	_ = l
  6973  	if len(m.Keyspaces) > 0 {
  6974  		for _, s := range m.Keyspaces {
  6975  			l = len(s)
  6976  			n += 1 + l + sov(uint64(l))
  6977  		}
  6978  	}
  6979  	if len(m.KeyspaceShards) > 0 {
  6980  		for _, s := range m.KeyspaceShards {
  6981  			l = len(s)
  6982  			n += 1 + l + sov(uint64(l))
  6983  		}
  6984  	}
  6985  	if len(m.Tablets) > 0 {
  6986  		for _, e := range m.Tablets {
  6987  			l = e.SizeVT()
  6988  			n += 1 + l + sov(uint64(l))
  6989  		}
  6990  	}
  6991  	if len(m.ClusterIds) > 0 {
  6992  		for _, s := range m.ClusterIds {
  6993  			l = len(s)
  6994  			n += 1 + l + sov(uint64(l))
  6995  		}
  6996  	}
  6997  	if m.Concurrency != 0 {
  6998  		n += 1 + sov(uint64(m.Concurrency))
  6999  	}
  7000  	l = len(m.WaitPosition)
  7001  	if l > 0 {
  7002  		n += 1 + l + sov(uint64(l))
  7003  	}
  7004  	if m.IncludePrimary {
  7005  		n += 2
  7006  	}
  7007  	n += len(m.unknownFields)
  7008  	return n
  7009  }
  7010  
  7011  func (m *ReloadSchemasResponse_KeyspaceResult) SizeVT() (n int) {
  7012  	if m == nil {
  7013  		return 0
  7014  	}
  7015  	var l int
  7016  	_ = l
  7017  	if m.Keyspace != nil {
  7018  		l = m.Keyspace.SizeVT()
  7019  		n += 1 + l + sov(uint64(l))
  7020  	}
  7021  	if len(m.Events) > 0 {
  7022  		for _, e := range m.Events {
  7023  			l = e.SizeVT()
  7024  			n += 1 + l + sov(uint64(l))
  7025  		}
  7026  	}
  7027  	n += len(m.unknownFields)
  7028  	return n
  7029  }
  7030  
  7031  func (m *ReloadSchemasResponse_ShardResult) SizeVT() (n int) {
  7032  	if m == nil {
  7033  		return 0
  7034  	}
  7035  	var l int
  7036  	_ = l
  7037  	if m.Shard != nil {
  7038  		l = m.Shard.SizeVT()
  7039  		n += 1 + l + sov(uint64(l))
  7040  	}
  7041  	if len(m.Events) > 0 {
  7042  		for _, e := range m.Events {
  7043  			l = e.SizeVT()
  7044  			n += 1 + l + sov(uint64(l))
  7045  		}
  7046  	}
  7047  	n += len(m.unknownFields)
  7048  	return n
  7049  }
  7050  
  7051  func (m *ReloadSchemasResponse_TabletResult) SizeVT() (n int) {
  7052  	if m == nil {
  7053  		return 0
  7054  	}
  7055  	var l int
  7056  	_ = l
  7057  	if m.Tablet != nil {
  7058  		l = m.Tablet.SizeVT()
  7059  		n += 1 + l + sov(uint64(l))
  7060  	}
  7061  	l = len(m.Result)
  7062  	if l > 0 {
  7063  		n += 1 + l + sov(uint64(l))
  7064  	}
  7065  	n += len(m.unknownFields)
  7066  	return n
  7067  }
  7068  
  7069  func (m *ReloadSchemasResponse) SizeVT() (n int) {
  7070  	if m == nil {
  7071  		return 0
  7072  	}
  7073  	var l int
  7074  	_ = l
  7075  	if len(m.KeyspaceResults) > 0 {
  7076  		for _, e := range m.KeyspaceResults {
  7077  			l = e.SizeVT()
  7078  			n += 1 + l + sov(uint64(l))
  7079  		}
  7080  	}
  7081  	if len(m.ShardResults) > 0 {
  7082  		for _, e := range m.ShardResults {
  7083  			l = e.SizeVT()
  7084  			n += 1 + l + sov(uint64(l))
  7085  		}
  7086  	}
  7087  	if len(m.TabletResults) > 0 {
  7088  		for _, e := range m.TabletResults {
  7089  			l = e.SizeVT()
  7090  			n += 1 + l + sov(uint64(l))
  7091  		}
  7092  	}
  7093  	n += len(m.unknownFields)
  7094  	return n
  7095  }
  7096  
  7097  func (m *ReloadSchemaShardRequest) SizeVT() (n int) {
  7098  	if m == nil {
  7099  		return 0
  7100  	}
  7101  	var l int
  7102  	_ = l
  7103  	l = len(m.ClusterId)
  7104  	if l > 0 {
  7105  		n += 1 + l + sov(uint64(l))
  7106  	}
  7107  	l = len(m.Keyspace)
  7108  	if l > 0 {
  7109  		n += 1 + l + sov(uint64(l))
  7110  	}
  7111  	l = len(m.Shard)
  7112  	if l > 0 {
  7113  		n += 1 + l + sov(uint64(l))
  7114  	}
  7115  	l = len(m.WaitPosition)
  7116  	if l > 0 {
  7117  		n += 1 + l + sov(uint64(l))
  7118  	}
  7119  	if m.IncludePrimary {
  7120  		n += 2
  7121  	}
  7122  	if m.Concurrency != 0 {
  7123  		n += 1 + sov(uint64(m.Concurrency))
  7124  	}
  7125  	n += len(m.unknownFields)
  7126  	return n
  7127  }
  7128  
  7129  func (m *ReloadSchemaShardResponse) SizeVT() (n int) {
  7130  	if m == nil {
  7131  		return 0
  7132  	}
  7133  	var l int
  7134  	_ = l
  7135  	if len(m.Events) > 0 {
  7136  		for _, e := range m.Events {
  7137  			l = e.SizeVT()
  7138  			n += 1 + l + sov(uint64(l))
  7139  		}
  7140  	}
  7141  	n += len(m.unknownFields)
  7142  	return n
  7143  }
  7144  
  7145  func (m *RefreshTabletReplicationSourceRequest) SizeVT() (n int) {
  7146  	if m == nil {
  7147  		return 0
  7148  	}
  7149  	var l int
  7150  	_ = l
  7151  	if m.Alias != nil {
  7152  		l = m.Alias.SizeVT()
  7153  		n += 1 + l + sov(uint64(l))
  7154  	}
  7155  	if len(m.ClusterIds) > 0 {
  7156  		for _, s := range m.ClusterIds {
  7157  			l = len(s)
  7158  			n += 1 + l + sov(uint64(l))
  7159  		}
  7160  	}
  7161  	n += len(m.unknownFields)
  7162  	return n
  7163  }
  7164  
  7165  func (m *RefreshTabletReplicationSourceResponse) SizeVT() (n int) {
  7166  	if m == nil {
  7167  		return 0
  7168  	}
  7169  	var l int
  7170  	_ = l
  7171  	l = len(m.Keyspace)
  7172  	if l > 0 {
  7173  		n += 1 + l + sov(uint64(l))
  7174  	}
  7175  	l = len(m.Shard)
  7176  	if l > 0 {
  7177  		n += 1 + l + sov(uint64(l))
  7178  	}
  7179  	if m.Primary != nil {
  7180  		l = m.Primary.SizeVT()
  7181  		n += 1 + l + sov(uint64(l))
  7182  	}
  7183  	if m.Cluster != nil {
  7184  		l = m.Cluster.SizeVT()
  7185  		n += 1 + l + sov(uint64(l))
  7186  	}
  7187  	n += len(m.unknownFields)
  7188  	return n
  7189  }
  7190  
  7191  func (m *RemoveKeyspaceCellRequest) SizeVT() (n int) {
  7192  	if m == nil {
  7193  		return 0
  7194  	}
  7195  	var l int
  7196  	_ = l
  7197  	l = len(m.ClusterId)
  7198  	if l > 0 {
  7199  		n += 1 + l + sov(uint64(l))
  7200  	}
  7201  	l = len(m.Keyspace)
  7202  	if l > 0 {
  7203  		n += 1 + l + sov(uint64(l))
  7204  	}
  7205  	l = len(m.Cell)
  7206  	if l > 0 {
  7207  		n += 1 + l + sov(uint64(l))
  7208  	}
  7209  	if m.Force {
  7210  		n += 2
  7211  	}
  7212  	if m.Recursive {
  7213  		n += 2
  7214  	}
  7215  	n += len(m.unknownFields)
  7216  	return n
  7217  }
  7218  
  7219  func (m *RemoveKeyspaceCellResponse) SizeVT() (n int) {
  7220  	if m == nil {
  7221  		return 0
  7222  	}
  7223  	var l int
  7224  	_ = l
  7225  	l = len(m.Status)
  7226  	if l > 0 {
  7227  		n += 1 + l + sov(uint64(l))
  7228  	}
  7229  	n += len(m.unknownFields)
  7230  	return n
  7231  }
  7232  
  7233  func (m *RunHealthCheckRequest) SizeVT() (n int) {
  7234  	if m == nil {
  7235  		return 0
  7236  	}
  7237  	var l int
  7238  	_ = l
  7239  	if m.Alias != nil {
  7240  		l = m.Alias.SizeVT()
  7241  		n += 1 + l + sov(uint64(l))
  7242  	}
  7243  	if len(m.ClusterIds) > 0 {
  7244  		for _, s := range m.ClusterIds {
  7245  			l = len(s)
  7246  			n += 1 + l + sov(uint64(l))
  7247  		}
  7248  	}
  7249  	n += len(m.unknownFields)
  7250  	return n
  7251  }
  7252  
  7253  func (m *RunHealthCheckResponse) SizeVT() (n int) {
  7254  	if m == nil {
  7255  		return 0
  7256  	}
  7257  	var l int
  7258  	_ = l
  7259  	l = len(m.Status)
  7260  	if l > 0 {
  7261  		n += 1 + l + sov(uint64(l))
  7262  	}
  7263  	if m.Cluster != nil {
  7264  		l = m.Cluster.SizeVT()
  7265  		n += 1 + l + sov(uint64(l))
  7266  	}
  7267  	n += len(m.unknownFields)
  7268  	return n
  7269  }
  7270  
  7271  func (m *SetReadOnlyRequest) SizeVT() (n int) {
  7272  	if m == nil {
  7273  		return 0
  7274  	}
  7275  	var l int
  7276  	_ = l
  7277  	if m.Alias != nil {
  7278  		l = m.Alias.SizeVT()
  7279  		n += 1 + l + sov(uint64(l))
  7280  	}
  7281  	if len(m.ClusterIds) > 0 {
  7282  		for _, s := range m.ClusterIds {
  7283  			l = len(s)
  7284  			n += 1 + l + sov(uint64(l))
  7285  		}
  7286  	}
  7287  	n += len(m.unknownFields)
  7288  	return n
  7289  }
  7290  
  7291  func (m *SetReadOnlyResponse) SizeVT() (n int) {
  7292  	if m == nil {
  7293  		return 0
  7294  	}
  7295  	var l int
  7296  	_ = l
  7297  	n += len(m.unknownFields)
  7298  	return n
  7299  }
  7300  
  7301  func (m *SetReadWriteRequest) SizeVT() (n int) {
  7302  	if m == nil {
  7303  		return 0
  7304  	}
  7305  	var l int
  7306  	_ = l
  7307  	if m.Alias != nil {
  7308  		l = m.Alias.SizeVT()
  7309  		n += 1 + l + sov(uint64(l))
  7310  	}
  7311  	if len(m.ClusterIds) > 0 {
  7312  		for _, s := range m.ClusterIds {
  7313  			l = len(s)
  7314  			n += 1 + l + sov(uint64(l))
  7315  		}
  7316  	}
  7317  	n += len(m.unknownFields)
  7318  	return n
  7319  }
  7320  
  7321  func (m *SetReadWriteResponse) SizeVT() (n int) {
  7322  	if m == nil {
  7323  		return 0
  7324  	}
  7325  	var l int
  7326  	_ = l
  7327  	n += len(m.unknownFields)
  7328  	return n
  7329  }
  7330  
  7331  func (m *StartReplicationRequest) SizeVT() (n int) {
  7332  	if m == nil {
  7333  		return 0
  7334  	}
  7335  	var l int
  7336  	_ = l
  7337  	if m.Alias != nil {
  7338  		l = m.Alias.SizeVT()
  7339  		n += 1 + l + sov(uint64(l))
  7340  	}
  7341  	if len(m.ClusterIds) > 0 {
  7342  		for _, s := range m.ClusterIds {
  7343  			l = len(s)
  7344  			n += 1 + l + sov(uint64(l))
  7345  		}
  7346  	}
  7347  	n += len(m.unknownFields)
  7348  	return n
  7349  }
  7350  
  7351  func (m *StartReplicationResponse) SizeVT() (n int) {
  7352  	if m == nil {
  7353  		return 0
  7354  	}
  7355  	var l int
  7356  	_ = l
  7357  	l = len(m.Status)
  7358  	if l > 0 {
  7359  		n += 1 + l + sov(uint64(l))
  7360  	}
  7361  	if m.Cluster != nil {
  7362  		l = m.Cluster.SizeVT()
  7363  		n += 1 + l + sov(uint64(l))
  7364  	}
  7365  	n += len(m.unknownFields)
  7366  	return n
  7367  }
  7368  
  7369  func (m *StopReplicationRequest) SizeVT() (n int) {
  7370  	if m == nil {
  7371  		return 0
  7372  	}
  7373  	var l int
  7374  	_ = l
  7375  	if m.Alias != nil {
  7376  		l = m.Alias.SizeVT()
  7377  		n += 1 + l + sov(uint64(l))
  7378  	}
  7379  	if len(m.ClusterIds) > 0 {
  7380  		for _, s := range m.ClusterIds {
  7381  			l = len(s)
  7382  			n += 1 + l + sov(uint64(l))
  7383  		}
  7384  	}
  7385  	n += len(m.unknownFields)
  7386  	return n
  7387  }
  7388  
  7389  func (m *StopReplicationResponse) SizeVT() (n int) {
  7390  	if m == nil {
  7391  		return 0
  7392  	}
  7393  	var l int
  7394  	_ = l
  7395  	l = len(m.Status)
  7396  	if l > 0 {
  7397  		n += 1 + l + sov(uint64(l))
  7398  	}
  7399  	if m.Cluster != nil {
  7400  		l = m.Cluster.SizeVT()
  7401  		n += 1 + l + sov(uint64(l))
  7402  	}
  7403  	n += len(m.unknownFields)
  7404  	return n
  7405  }
  7406  
  7407  func (m *TabletExternallyPromotedRequest) SizeVT() (n int) {
  7408  	if m == nil {
  7409  		return 0
  7410  	}
  7411  	var l int
  7412  	_ = l
  7413  	if m.Alias != nil {
  7414  		l = m.Alias.SizeVT()
  7415  		n += 1 + l + sov(uint64(l))
  7416  	}
  7417  	if len(m.ClusterIds) > 0 {
  7418  		for _, s := range m.ClusterIds {
  7419  			l = len(s)
  7420  			n += 1 + l + sov(uint64(l))
  7421  		}
  7422  	}
  7423  	n += len(m.unknownFields)
  7424  	return n
  7425  }
  7426  
  7427  func (m *TabletExternallyPromotedResponse) SizeVT() (n int) {
  7428  	if m == nil {
  7429  		return 0
  7430  	}
  7431  	var l int
  7432  	_ = l
  7433  	if m.Cluster != nil {
  7434  		l = m.Cluster.SizeVT()
  7435  		n += 1 + l + sov(uint64(l))
  7436  	}
  7437  	l = len(m.Keyspace)
  7438  	if l > 0 {
  7439  		n += 1 + l + sov(uint64(l))
  7440  	}
  7441  	l = len(m.Shard)
  7442  	if l > 0 {
  7443  		n += 1 + l + sov(uint64(l))
  7444  	}
  7445  	if m.NewPrimary != nil {
  7446  		l = m.NewPrimary.SizeVT()
  7447  		n += 1 + l + sov(uint64(l))
  7448  	}
  7449  	if m.OldPrimary != nil {
  7450  		l = m.OldPrimary.SizeVT()
  7451  		n += 1 + l + sov(uint64(l))
  7452  	}
  7453  	n += len(m.unknownFields)
  7454  	return n
  7455  }
  7456  
  7457  func (m *TabletExternallyReparentedRequest) SizeVT() (n int) {
  7458  	if m == nil {
  7459  		return 0
  7460  	}
  7461  	var l int
  7462  	_ = l
  7463  	if m.Alias != nil {
  7464  		l = m.Alias.SizeVT()
  7465  		n += 1 + l + sov(uint64(l))
  7466  	}
  7467  	if len(m.ClusterIds) > 0 {
  7468  		for _, s := range m.ClusterIds {
  7469  			l = len(s)
  7470  			n += 1 + l + sov(uint64(l))
  7471  		}
  7472  	}
  7473  	n += len(m.unknownFields)
  7474  	return n
  7475  }
  7476  
  7477  func (m *ValidateRequest) SizeVT() (n int) {
  7478  	if m == nil {
  7479  		return 0
  7480  	}
  7481  	var l int
  7482  	_ = l
  7483  	l = len(m.ClusterId)
  7484  	if l > 0 {
  7485  		n += 1 + l + sov(uint64(l))
  7486  	}
  7487  	if m.PingTablets {
  7488  		n += 2
  7489  	}
  7490  	n += len(m.unknownFields)
  7491  	return n
  7492  }
  7493  
  7494  func (m *ValidateKeyspaceRequest) SizeVT() (n int) {
  7495  	if m == nil {
  7496  		return 0
  7497  	}
  7498  	var l int
  7499  	_ = l
  7500  	l = len(m.ClusterId)
  7501  	if l > 0 {
  7502  		n += 1 + l + sov(uint64(l))
  7503  	}
  7504  	l = len(m.Keyspace)
  7505  	if l > 0 {
  7506  		n += 1 + l + sov(uint64(l))
  7507  	}
  7508  	if m.PingTablets {
  7509  		n += 2
  7510  	}
  7511  	n += len(m.unknownFields)
  7512  	return n
  7513  }
  7514  
  7515  func (m *ValidateSchemaKeyspaceRequest) SizeVT() (n int) {
  7516  	if m == nil {
  7517  		return 0
  7518  	}
  7519  	var l int
  7520  	_ = l
  7521  	l = len(m.ClusterId)
  7522  	if l > 0 {
  7523  		n += 1 + l + sov(uint64(l))
  7524  	}
  7525  	l = len(m.Keyspace)
  7526  	if l > 0 {
  7527  		n += 1 + l + sov(uint64(l))
  7528  	}
  7529  	n += len(m.unknownFields)
  7530  	return n
  7531  }
  7532  
  7533  func (m *ValidateShardRequest) SizeVT() (n int) {
  7534  	if m == nil {
  7535  		return 0
  7536  	}
  7537  	var l int
  7538  	_ = l
  7539  	l = len(m.ClusterId)
  7540  	if l > 0 {
  7541  		n += 1 + l + sov(uint64(l))
  7542  	}
  7543  	l = len(m.Keyspace)
  7544  	if l > 0 {
  7545  		n += 1 + l + sov(uint64(l))
  7546  	}
  7547  	l = len(m.Shard)
  7548  	if l > 0 {
  7549  		n += 1 + l + sov(uint64(l))
  7550  	}
  7551  	if m.PingTablets {
  7552  		n += 2
  7553  	}
  7554  	n += len(m.unknownFields)
  7555  	return n
  7556  }
  7557  
  7558  func (m *ValidateVersionKeyspaceRequest) SizeVT() (n int) {
  7559  	if m == nil {
  7560  		return 0
  7561  	}
  7562  	var l int
  7563  	_ = l
  7564  	l = len(m.ClusterId)
  7565  	if l > 0 {
  7566  		n += 1 + l + sov(uint64(l))
  7567  	}
  7568  	l = len(m.Keyspace)
  7569  	if l > 0 {
  7570  		n += 1 + l + sov(uint64(l))
  7571  	}
  7572  	n += len(m.unknownFields)
  7573  	return n
  7574  }
  7575  
  7576  func (m *ValidateVersionShardRequest) SizeVT() (n int) {
  7577  	if m == nil {
  7578  		return 0
  7579  	}
  7580  	var l int
  7581  	_ = l
  7582  	l = len(m.ClusterId)
  7583  	if l > 0 {
  7584  		n += 1 + l + sov(uint64(l))
  7585  	}
  7586  	l = len(m.Keyspace)
  7587  	if l > 0 {
  7588  		n += 1 + l + sov(uint64(l))
  7589  	}
  7590  	l = len(m.Shard)
  7591  	if l > 0 {
  7592  		n += 1 + l + sov(uint64(l))
  7593  	}
  7594  	n += len(m.unknownFields)
  7595  	return n
  7596  }
  7597  
  7598  func (m *VTExplainRequest) SizeVT() (n int) {
  7599  	if m == nil {
  7600  		return 0
  7601  	}
  7602  	var l int
  7603  	_ = l
  7604  	l = len(m.Cluster)
  7605  	if l > 0 {
  7606  		n += 1 + l + sov(uint64(l))
  7607  	}
  7608  	l = len(m.Keyspace)
  7609  	if l > 0 {
  7610  		n += 1 + l + sov(uint64(l))
  7611  	}
  7612  	l = len(m.Sql)
  7613  	if l > 0 {
  7614  		n += 1 + l + sov(uint64(l))
  7615  	}
  7616  	n += len(m.unknownFields)
  7617  	return n
  7618  }
  7619  
  7620  func (m *VTExplainResponse) SizeVT() (n int) {
  7621  	if m == nil {
  7622  		return 0
  7623  	}
  7624  	var l int
  7625  	_ = l
  7626  	l = len(m.Response)
  7627  	if l > 0 {
  7628  		n += 1 + l + sov(uint64(l))
  7629  	}
  7630  	n += len(m.unknownFields)
  7631  	return n
  7632  }
  7633  
  7634  func sov(x uint64) (n int) {
  7635  	return (bits.Len64(x|1) + 6) / 7
  7636  }
  7637  func soz(x uint64) (n int) {
  7638  	return sov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  7639  }
  7640  func (m *Cluster) UnmarshalVT(dAtA []byte) error {
  7641  	l := len(dAtA)
  7642  	iNdEx := 0
  7643  	for iNdEx < l {
  7644  		preIndex := iNdEx
  7645  		var wire uint64
  7646  		for shift := uint(0); ; shift += 7 {
  7647  			if shift >= 64 {
  7648  				return ErrIntOverflow
  7649  			}
  7650  			if iNdEx >= l {
  7651  				return io.ErrUnexpectedEOF
  7652  			}
  7653  			b := dAtA[iNdEx]
  7654  			iNdEx++
  7655  			wire |= uint64(b&0x7F) << shift
  7656  			if b < 0x80 {
  7657  				break
  7658  			}
  7659  		}
  7660  		fieldNum := int32(wire >> 3)
  7661  		wireType := int(wire & 0x7)
  7662  		if wireType == 4 {
  7663  			return fmt.Errorf("proto: Cluster: wiretype end group for non-group")
  7664  		}
  7665  		if fieldNum <= 0 {
  7666  			return fmt.Errorf("proto: Cluster: illegal tag %d (wire type %d)", fieldNum, wire)
  7667  		}
  7668  		switch fieldNum {
  7669  		case 1:
  7670  			if wireType != 2 {
  7671  				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
  7672  			}
  7673  			var stringLen uint64
  7674  			for shift := uint(0); ; shift += 7 {
  7675  				if shift >= 64 {
  7676  					return ErrIntOverflow
  7677  				}
  7678  				if iNdEx >= l {
  7679  					return io.ErrUnexpectedEOF
  7680  				}
  7681  				b := dAtA[iNdEx]
  7682  				iNdEx++
  7683  				stringLen |= uint64(b&0x7F) << shift
  7684  				if b < 0x80 {
  7685  					break
  7686  				}
  7687  			}
  7688  			intStringLen := int(stringLen)
  7689  			if intStringLen < 0 {
  7690  				return ErrInvalidLength
  7691  			}
  7692  			postIndex := iNdEx + intStringLen
  7693  			if postIndex < 0 {
  7694  				return ErrInvalidLength
  7695  			}
  7696  			if postIndex > l {
  7697  				return io.ErrUnexpectedEOF
  7698  			}
  7699  			m.Id = string(dAtA[iNdEx:postIndex])
  7700  			iNdEx = postIndex
  7701  		case 2:
  7702  			if wireType != 2 {
  7703  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  7704  			}
  7705  			var stringLen uint64
  7706  			for shift := uint(0); ; shift += 7 {
  7707  				if shift >= 64 {
  7708  					return ErrIntOverflow
  7709  				}
  7710  				if iNdEx >= l {
  7711  					return io.ErrUnexpectedEOF
  7712  				}
  7713  				b := dAtA[iNdEx]
  7714  				iNdEx++
  7715  				stringLen |= uint64(b&0x7F) << shift
  7716  				if b < 0x80 {
  7717  					break
  7718  				}
  7719  			}
  7720  			intStringLen := int(stringLen)
  7721  			if intStringLen < 0 {
  7722  				return ErrInvalidLength
  7723  			}
  7724  			postIndex := iNdEx + intStringLen
  7725  			if postIndex < 0 {
  7726  				return ErrInvalidLength
  7727  			}
  7728  			if postIndex > l {
  7729  				return io.ErrUnexpectedEOF
  7730  			}
  7731  			m.Name = string(dAtA[iNdEx:postIndex])
  7732  			iNdEx = postIndex
  7733  		default:
  7734  			iNdEx = preIndex
  7735  			skippy, err := skip(dAtA[iNdEx:])
  7736  			if err != nil {
  7737  				return err
  7738  			}
  7739  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7740  				return ErrInvalidLength
  7741  			}
  7742  			if (iNdEx + skippy) > l {
  7743  				return io.ErrUnexpectedEOF
  7744  			}
  7745  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7746  			iNdEx += skippy
  7747  		}
  7748  	}
  7749  
  7750  	if iNdEx > l {
  7751  		return io.ErrUnexpectedEOF
  7752  	}
  7753  	return nil
  7754  }
  7755  func (m *ClusterBackup) UnmarshalVT(dAtA []byte) error {
  7756  	l := len(dAtA)
  7757  	iNdEx := 0
  7758  	for iNdEx < l {
  7759  		preIndex := iNdEx
  7760  		var wire uint64
  7761  		for shift := uint(0); ; shift += 7 {
  7762  			if shift >= 64 {
  7763  				return ErrIntOverflow
  7764  			}
  7765  			if iNdEx >= l {
  7766  				return io.ErrUnexpectedEOF
  7767  			}
  7768  			b := dAtA[iNdEx]
  7769  			iNdEx++
  7770  			wire |= uint64(b&0x7F) << shift
  7771  			if b < 0x80 {
  7772  				break
  7773  			}
  7774  		}
  7775  		fieldNum := int32(wire >> 3)
  7776  		wireType := int(wire & 0x7)
  7777  		if wireType == 4 {
  7778  			return fmt.Errorf("proto: ClusterBackup: wiretype end group for non-group")
  7779  		}
  7780  		if fieldNum <= 0 {
  7781  			return fmt.Errorf("proto: ClusterBackup: illegal tag %d (wire type %d)", fieldNum, wire)
  7782  		}
  7783  		switch fieldNum {
  7784  		case 1:
  7785  			if wireType != 2 {
  7786  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  7787  			}
  7788  			var msglen int
  7789  			for shift := uint(0); ; shift += 7 {
  7790  				if shift >= 64 {
  7791  					return ErrIntOverflow
  7792  				}
  7793  				if iNdEx >= l {
  7794  					return io.ErrUnexpectedEOF
  7795  				}
  7796  				b := dAtA[iNdEx]
  7797  				iNdEx++
  7798  				msglen |= int(b&0x7F) << shift
  7799  				if b < 0x80 {
  7800  					break
  7801  				}
  7802  			}
  7803  			if msglen < 0 {
  7804  				return ErrInvalidLength
  7805  			}
  7806  			postIndex := iNdEx + msglen
  7807  			if postIndex < 0 {
  7808  				return ErrInvalidLength
  7809  			}
  7810  			if postIndex > l {
  7811  				return io.ErrUnexpectedEOF
  7812  			}
  7813  			if m.Cluster == nil {
  7814  				m.Cluster = &Cluster{}
  7815  			}
  7816  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7817  				return err
  7818  			}
  7819  			iNdEx = postIndex
  7820  		case 2:
  7821  			if wireType != 2 {
  7822  				return fmt.Errorf("proto: wrong wireType = %d for field Backup", wireType)
  7823  			}
  7824  			var msglen int
  7825  			for shift := uint(0); ; shift += 7 {
  7826  				if shift >= 64 {
  7827  					return ErrIntOverflow
  7828  				}
  7829  				if iNdEx >= l {
  7830  					return io.ErrUnexpectedEOF
  7831  				}
  7832  				b := dAtA[iNdEx]
  7833  				iNdEx++
  7834  				msglen |= int(b&0x7F) << shift
  7835  				if b < 0x80 {
  7836  					break
  7837  				}
  7838  			}
  7839  			if msglen < 0 {
  7840  				return ErrInvalidLength
  7841  			}
  7842  			postIndex := iNdEx + msglen
  7843  			if postIndex < 0 {
  7844  				return ErrInvalidLength
  7845  			}
  7846  			if postIndex > l {
  7847  				return io.ErrUnexpectedEOF
  7848  			}
  7849  			if m.Backup == nil {
  7850  				m.Backup = &mysqlctl.BackupInfo{}
  7851  			}
  7852  			if err := m.Backup.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7853  				return err
  7854  			}
  7855  			iNdEx = postIndex
  7856  		default:
  7857  			iNdEx = preIndex
  7858  			skippy, err := skip(dAtA[iNdEx:])
  7859  			if err != nil {
  7860  				return err
  7861  			}
  7862  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7863  				return ErrInvalidLength
  7864  			}
  7865  			if (iNdEx + skippy) > l {
  7866  				return io.ErrUnexpectedEOF
  7867  			}
  7868  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7869  			iNdEx += skippy
  7870  		}
  7871  	}
  7872  
  7873  	if iNdEx > l {
  7874  		return io.ErrUnexpectedEOF
  7875  	}
  7876  	return nil
  7877  }
  7878  func (m *ClusterCellsAliases) UnmarshalVT(dAtA []byte) error {
  7879  	l := len(dAtA)
  7880  	iNdEx := 0
  7881  	for iNdEx < l {
  7882  		preIndex := iNdEx
  7883  		var wire uint64
  7884  		for shift := uint(0); ; shift += 7 {
  7885  			if shift >= 64 {
  7886  				return ErrIntOverflow
  7887  			}
  7888  			if iNdEx >= l {
  7889  				return io.ErrUnexpectedEOF
  7890  			}
  7891  			b := dAtA[iNdEx]
  7892  			iNdEx++
  7893  			wire |= uint64(b&0x7F) << shift
  7894  			if b < 0x80 {
  7895  				break
  7896  			}
  7897  		}
  7898  		fieldNum := int32(wire >> 3)
  7899  		wireType := int(wire & 0x7)
  7900  		if wireType == 4 {
  7901  			return fmt.Errorf("proto: ClusterCellsAliases: wiretype end group for non-group")
  7902  		}
  7903  		if fieldNum <= 0 {
  7904  			return fmt.Errorf("proto: ClusterCellsAliases: illegal tag %d (wire type %d)", fieldNum, wire)
  7905  		}
  7906  		switch fieldNum {
  7907  		case 1:
  7908  			if wireType != 2 {
  7909  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  7910  			}
  7911  			var msglen int
  7912  			for shift := uint(0); ; shift += 7 {
  7913  				if shift >= 64 {
  7914  					return ErrIntOverflow
  7915  				}
  7916  				if iNdEx >= l {
  7917  					return io.ErrUnexpectedEOF
  7918  				}
  7919  				b := dAtA[iNdEx]
  7920  				iNdEx++
  7921  				msglen |= int(b&0x7F) << shift
  7922  				if b < 0x80 {
  7923  					break
  7924  				}
  7925  			}
  7926  			if msglen < 0 {
  7927  				return ErrInvalidLength
  7928  			}
  7929  			postIndex := iNdEx + msglen
  7930  			if postIndex < 0 {
  7931  				return ErrInvalidLength
  7932  			}
  7933  			if postIndex > l {
  7934  				return io.ErrUnexpectedEOF
  7935  			}
  7936  			if m.Cluster == nil {
  7937  				m.Cluster = &Cluster{}
  7938  			}
  7939  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7940  				return err
  7941  			}
  7942  			iNdEx = postIndex
  7943  		case 2:
  7944  			if wireType != 2 {
  7945  				return fmt.Errorf("proto: wrong wireType = %d for field Aliases", wireType)
  7946  			}
  7947  			var msglen int
  7948  			for shift := uint(0); ; shift += 7 {
  7949  				if shift >= 64 {
  7950  					return ErrIntOverflow
  7951  				}
  7952  				if iNdEx >= l {
  7953  					return io.ErrUnexpectedEOF
  7954  				}
  7955  				b := dAtA[iNdEx]
  7956  				iNdEx++
  7957  				msglen |= int(b&0x7F) << shift
  7958  				if b < 0x80 {
  7959  					break
  7960  				}
  7961  			}
  7962  			if msglen < 0 {
  7963  				return ErrInvalidLength
  7964  			}
  7965  			postIndex := iNdEx + msglen
  7966  			if postIndex < 0 {
  7967  				return ErrInvalidLength
  7968  			}
  7969  			if postIndex > l {
  7970  				return io.ErrUnexpectedEOF
  7971  			}
  7972  			if m.Aliases == nil {
  7973  				m.Aliases = make(map[string]*topodata.CellsAlias)
  7974  			}
  7975  			var mapkey string
  7976  			var mapvalue *topodata.CellsAlias
  7977  			for iNdEx < postIndex {
  7978  				entryPreIndex := iNdEx
  7979  				var wire uint64
  7980  				for shift := uint(0); ; shift += 7 {
  7981  					if shift >= 64 {
  7982  						return ErrIntOverflow
  7983  					}
  7984  					if iNdEx >= l {
  7985  						return io.ErrUnexpectedEOF
  7986  					}
  7987  					b := dAtA[iNdEx]
  7988  					iNdEx++
  7989  					wire |= uint64(b&0x7F) << shift
  7990  					if b < 0x80 {
  7991  						break
  7992  					}
  7993  				}
  7994  				fieldNum := int32(wire >> 3)
  7995  				if fieldNum == 1 {
  7996  					var stringLenmapkey uint64
  7997  					for shift := uint(0); ; shift += 7 {
  7998  						if shift >= 64 {
  7999  							return ErrIntOverflow
  8000  						}
  8001  						if iNdEx >= l {
  8002  							return io.ErrUnexpectedEOF
  8003  						}
  8004  						b := dAtA[iNdEx]
  8005  						iNdEx++
  8006  						stringLenmapkey |= uint64(b&0x7F) << shift
  8007  						if b < 0x80 {
  8008  							break
  8009  						}
  8010  					}
  8011  					intStringLenmapkey := int(stringLenmapkey)
  8012  					if intStringLenmapkey < 0 {
  8013  						return ErrInvalidLength
  8014  					}
  8015  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  8016  					if postStringIndexmapkey < 0 {
  8017  						return ErrInvalidLength
  8018  					}
  8019  					if postStringIndexmapkey > l {
  8020  						return io.ErrUnexpectedEOF
  8021  					}
  8022  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  8023  					iNdEx = postStringIndexmapkey
  8024  				} else if fieldNum == 2 {
  8025  					var mapmsglen int
  8026  					for shift := uint(0); ; shift += 7 {
  8027  						if shift >= 64 {
  8028  							return ErrIntOverflow
  8029  						}
  8030  						if iNdEx >= l {
  8031  							return io.ErrUnexpectedEOF
  8032  						}
  8033  						b := dAtA[iNdEx]
  8034  						iNdEx++
  8035  						mapmsglen |= int(b&0x7F) << shift
  8036  						if b < 0x80 {
  8037  							break
  8038  						}
  8039  					}
  8040  					if mapmsglen < 0 {
  8041  						return ErrInvalidLength
  8042  					}
  8043  					postmsgIndex := iNdEx + mapmsglen
  8044  					if postmsgIndex < 0 {
  8045  						return ErrInvalidLength
  8046  					}
  8047  					if postmsgIndex > l {
  8048  						return io.ErrUnexpectedEOF
  8049  					}
  8050  					mapvalue = &topodata.CellsAlias{}
  8051  					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
  8052  						return err
  8053  					}
  8054  					iNdEx = postmsgIndex
  8055  				} else {
  8056  					iNdEx = entryPreIndex
  8057  					skippy, err := skip(dAtA[iNdEx:])
  8058  					if err != nil {
  8059  						return err
  8060  					}
  8061  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  8062  						return ErrInvalidLength
  8063  					}
  8064  					if (iNdEx + skippy) > postIndex {
  8065  						return io.ErrUnexpectedEOF
  8066  					}
  8067  					iNdEx += skippy
  8068  				}
  8069  			}
  8070  			m.Aliases[mapkey] = mapvalue
  8071  			iNdEx = postIndex
  8072  		default:
  8073  			iNdEx = preIndex
  8074  			skippy, err := skip(dAtA[iNdEx:])
  8075  			if err != nil {
  8076  				return err
  8077  			}
  8078  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8079  				return ErrInvalidLength
  8080  			}
  8081  			if (iNdEx + skippy) > l {
  8082  				return io.ErrUnexpectedEOF
  8083  			}
  8084  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8085  			iNdEx += skippy
  8086  		}
  8087  	}
  8088  
  8089  	if iNdEx > l {
  8090  		return io.ErrUnexpectedEOF
  8091  	}
  8092  	return nil
  8093  }
  8094  func (m *ClusterCellInfo) UnmarshalVT(dAtA []byte) error {
  8095  	l := len(dAtA)
  8096  	iNdEx := 0
  8097  	for iNdEx < l {
  8098  		preIndex := iNdEx
  8099  		var wire uint64
  8100  		for shift := uint(0); ; shift += 7 {
  8101  			if shift >= 64 {
  8102  				return ErrIntOverflow
  8103  			}
  8104  			if iNdEx >= l {
  8105  				return io.ErrUnexpectedEOF
  8106  			}
  8107  			b := dAtA[iNdEx]
  8108  			iNdEx++
  8109  			wire |= uint64(b&0x7F) << shift
  8110  			if b < 0x80 {
  8111  				break
  8112  			}
  8113  		}
  8114  		fieldNum := int32(wire >> 3)
  8115  		wireType := int(wire & 0x7)
  8116  		if wireType == 4 {
  8117  			return fmt.Errorf("proto: ClusterCellInfo: wiretype end group for non-group")
  8118  		}
  8119  		if fieldNum <= 0 {
  8120  			return fmt.Errorf("proto: ClusterCellInfo: illegal tag %d (wire type %d)", fieldNum, wire)
  8121  		}
  8122  		switch fieldNum {
  8123  		case 1:
  8124  			if wireType != 2 {
  8125  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  8126  			}
  8127  			var msglen int
  8128  			for shift := uint(0); ; shift += 7 {
  8129  				if shift >= 64 {
  8130  					return ErrIntOverflow
  8131  				}
  8132  				if iNdEx >= l {
  8133  					return io.ErrUnexpectedEOF
  8134  				}
  8135  				b := dAtA[iNdEx]
  8136  				iNdEx++
  8137  				msglen |= int(b&0x7F) << shift
  8138  				if b < 0x80 {
  8139  					break
  8140  				}
  8141  			}
  8142  			if msglen < 0 {
  8143  				return ErrInvalidLength
  8144  			}
  8145  			postIndex := iNdEx + msglen
  8146  			if postIndex < 0 {
  8147  				return ErrInvalidLength
  8148  			}
  8149  			if postIndex > l {
  8150  				return io.ErrUnexpectedEOF
  8151  			}
  8152  			if m.Cluster == nil {
  8153  				m.Cluster = &Cluster{}
  8154  			}
  8155  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8156  				return err
  8157  			}
  8158  			iNdEx = postIndex
  8159  		case 2:
  8160  			if wireType != 2 {
  8161  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  8162  			}
  8163  			var stringLen uint64
  8164  			for shift := uint(0); ; shift += 7 {
  8165  				if shift >= 64 {
  8166  					return ErrIntOverflow
  8167  				}
  8168  				if iNdEx >= l {
  8169  					return io.ErrUnexpectedEOF
  8170  				}
  8171  				b := dAtA[iNdEx]
  8172  				iNdEx++
  8173  				stringLen |= uint64(b&0x7F) << shift
  8174  				if b < 0x80 {
  8175  					break
  8176  				}
  8177  			}
  8178  			intStringLen := int(stringLen)
  8179  			if intStringLen < 0 {
  8180  				return ErrInvalidLength
  8181  			}
  8182  			postIndex := iNdEx + intStringLen
  8183  			if postIndex < 0 {
  8184  				return ErrInvalidLength
  8185  			}
  8186  			if postIndex > l {
  8187  				return io.ErrUnexpectedEOF
  8188  			}
  8189  			m.Name = string(dAtA[iNdEx:postIndex])
  8190  			iNdEx = postIndex
  8191  		case 3:
  8192  			if wireType != 2 {
  8193  				return fmt.Errorf("proto: wrong wireType = %d for field CellInfo", wireType)
  8194  			}
  8195  			var msglen int
  8196  			for shift := uint(0); ; shift += 7 {
  8197  				if shift >= 64 {
  8198  					return ErrIntOverflow
  8199  				}
  8200  				if iNdEx >= l {
  8201  					return io.ErrUnexpectedEOF
  8202  				}
  8203  				b := dAtA[iNdEx]
  8204  				iNdEx++
  8205  				msglen |= int(b&0x7F) << shift
  8206  				if b < 0x80 {
  8207  					break
  8208  				}
  8209  			}
  8210  			if msglen < 0 {
  8211  				return ErrInvalidLength
  8212  			}
  8213  			postIndex := iNdEx + msglen
  8214  			if postIndex < 0 {
  8215  				return ErrInvalidLength
  8216  			}
  8217  			if postIndex > l {
  8218  				return io.ErrUnexpectedEOF
  8219  			}
  8220  			if m.CellInfo == nil {
  8221  				m.CellInfo = &topodata.CellInfo{}
  8222  			}
  8223  			if err := m.CellInfo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8224  				return err
  8225  			}
  8226  			iNdEx = postIndex
  8227  		default:
  8228  			iNdEx = preIndex
  8229  			skippy, err := skip(dAtA[iNdEx:])
  8230  			if err != nil {
  8231  				return err
  8232  			}
  8233  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8234  				return ErrInvalidLength
  8235  			}
  8236  			if (iNdEx + skippy) > l {
  8237  				return io.ErrUnexpectedEOF
  8238  			}
  8239  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8240  			iNdEx += skippy
  8241  		}
  8242  	}
  8243  
  8244  	if iNdEx > l {
  8245  		return io.ErrUnexpectedEOF
  8246  	}
  8247  	return nil
  8248  }
  8249  func (m *ClusterShardReplicationPosition) UnmarshalVT(dAtA []byte) error {
  8250  	l := len(dAtA)
  8251  	iNdEx := 0
  8252  	for iNdEx < l {
  8253  		preIndex := iNdEx
  8254  		var wire uint64
  8255  		for shift := uint(0); ; shift += 7 {
  8256  			if shift >= 64 {
  8257  				return ErrIntOverflow
  8258  			}
  8259  			if iNdEx >= l {
  8260  				return io.ErrUnexpectedEOF
  8261  			}
  8262  			b := dAtA[iNdEx]
  8263  			iNdEx++
  8264  			wire |= uint64(b&0x7F) << shift
  8265  			if b < 0x80 {
  8266  				break
  8267  			}
  8268  		}
  8269  		fieldNum := int32(wire >> 3)
  8270  		wireType := int(wire & 0x7)
  8271  		if wireType == 4 {
  8272  			return fmt.Errorf("proto: ClusterShardReplicationPosition: wiretype end group for non-group")
  8273  		}
  8274  		if fieldNum <= 0 {
  8275  			return fmt.Errorf("proto: ClusterShardReplicationPosition: illegal tag %d (wire type %d)", fieldNum, wire)
  8276  		}
  8277  		switch fieldNum {
  8278  		case 1:
  8279  			if wireType != 2 {
  8280  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  8281  			}
  8282  			var msglen int
  8283  			for shift := uint(0); ; shift += 7 {
  8284  				if shift >= 64 {
  8285  					return ErrIntOverflow
  8286  				}
  8287  				if iNdEx >= l {
  8288  					return io.ErrUnexpectedEOF
  8289  				}
  8290  				b := dAtA[iNdEx]
  8291  				iNdEx++
  8292  				msglen |= int(b&0x7F) << shift
  8293  				if b < 0x80 {
  8294  					break
  8295  				}
  8296  			}
  8297  			if msglen < 0 {
  8298  				return ErrInvalidLength
  8299  			}
  8300  			postIndex := iNdEx + msglen
  8301  			if postIndex < 0 {
  8302  				return ErrInvalidLength
  8303  			}
  8304  			if postIndex > l {
  8305  				return io.ErrUnexpectedEOF
  8306  			}
  8307  			if m.Cluster == nil {
  8308  				m.Cluster = &Cluster{}
  8309  			}
  8310  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8311  				return err
  8312  			}
  8313  			iNdEx = postIndex
  8314  		case 2:
  8315  			if wireType != 2 {
  8316  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
  8317  			}
  8318  			var stringLen uint64
  8319  			for shift := uint(0); ; shift += 7 {
  8320  				if shift >= 64 {
  8321  					return ErrIntOverflow
  8322  				}
  8323  				if iNdEx >= l {
  8324  					return io.ErrUnexpectedEOF
  8325  				}
  8326  				b := dAtA[iNdEx]
  8327  				iNdEx++
  8328  				stringLen |= uint64(b&0x7F) << shift
  8329  				if b < 0x80 {
  8330  					break
  8331  				}
  8332  			}
  8333  			intStringLen := int(stringLen)
  8334  			if intStringLen < 0 {
  8335  				return ErrInvalidLength
  8336  			}
  8337  			postIndex := iNdEx + intStringLen
  8338  			if postIndex < 0 {
  8339  				return ErrInvalidLength
  8340  			}
  8341  			if postIndex > l {
  8342  				return io.ErrUnexpectedEOF
  8343  			}
  8344  			m.Keyspace = string(dAtA[iNdEx:postIndex])
  8345  			iNdEx = postIndex
  8346  		case 3:
  8347  			if wireType != 2 {
  8348  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
  8349  			}
  8350  			var stringLen uint64
  8351  			for shift := uint(0); ; shift += 7 {
  8352  				if shift >= 64 {
  8353  					return ErrIntOverflow
  8354  				}
  8355  				if iNdEx >= l {
  8356  					return io.ErrUnexpectedEOF
  8357  				}
  8358  				b := dAtA[iNdEx]
  8359  				iNdEx++
  8360  				stringLen |= uint64(b&0x7F) << shift
  8361  				if b < 0x80 {
  8362  					break
  8363  				}
  8364  			}
  8365  			intStringLen := int(stringLen)
  8366  			if intStringLen < 0 {
  8367  				return ErrInvalidLength
  8368  			}
  8369  			postIndex := iNdEx + intStringLen
  8370  			if postIndex < 0 {
  8371  				return ErrInvalidLength
  8372  			}
  8373  			if postIndex > l {
  8374  				return io.ErrUnexpectedEOF
  8375  			}
  8376  			m.Shard = string(dAtA[iNdEx:postIndex])
  8377  			iNdEx = postIndex
  8378  		case 4:
  8379  			if wireType != 2 {
  8380  				return fmt.Errorf("proto: wrong wireType = %d for field PositionInfo", wireType)
  8381  			}
  8382  			var msglen int
  8383  			for shift := uint(0); ; shift += 7 {
  8384  				if shift >= 64 {
  8385  					return ErrIntOverflow
  8386  				}
  8387  				if iNdEx >= l {
  8388  					return io.ErrUnexpectedEOF
  8389  				}
  8390  				b := dAtA[iNdEx]
  8391  				iNdEx++
  8392  				msglen |= int(b&0x7F) << shift
  8393  				if b < 0x80 {
  8394  					break
  8395  				}
  8396  			}
  8397  			if msglen < 0 {
  8398  				return ErrInvalidLength
  8399  			}
  8400  			postIndex := iNdEx + msglen
  8401  			if postIndex < 0 {
  8402  				return ErrInvalidLength
  8403  			}
  8404  			if postIndex > l {
  8405  				return io.ErrUnexpectedEOF
  8406  			}
  8407  			if m.PositionInfo == nil {
  8408  				m.PositionInfo = &vtctldata.ShardReplicationPositionsResponse{}
  8409  			}
  8410  			if err := m.PositionInfo.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8411  				return err
  8412  			}
  8413  			iNdEx = postIndex
  8414  		default:
  8415  			iNdEx = preIndex
  8416  			skippy, err := skip(dAtA[iNdEx:])
  8417  			if err != nil {
  8418  				return err
  8419  			}
  8420  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8421  				return ErrInvalidLength
  8422  			}
  8423  			if (iNdEx + skippy) > l {
  8424  				return io.ErrUnexpectedEOF
  8425  			}
  8426  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8427  			iNdEx += skippy
  8428  		}
  8429  	}
  8430  
  8431  	if iNdEx > l {
  8432  		return io.ErrUnexpectedEOF
  8433  	}
  8434  	return nil
  8435  }
  8436  func (m *ClusterWorkflows) UnmarshalVT(dAtA []byte) error {
  8437  	l := len(dAtA)
  8438  	iNdEx := 0
  8439  	for iNdEx < l {
  8440  		preIndex := iNdEx
  8441  		var wire uint64
  8442  		for shift := uint(0); ; shift += 7 {
  8443  			if shift >= 64 {
  8444  				return ErrIntOverflow
  8445  			}
  8446  			if iNdEx >= l {
  8447  				return io.ErrUnexpectedEOF
  8448  			}
  8449  			b := dAtA[iNdEx]
  8450  			iNdEx++
  8451  			wire |= uint64(b&0x7F) << shift
  8452  			if b < 0x80 {
  8453  				break
  8454  			}
  8455  		}
  8456  		fieldNum := int32(wire >> 3)
  8457  		wireType := int(wire & 0x7)
  8458  		if wireType == 4 {
  8459  			return fmt.Errorf("proto: ClusterWorkflows: wiretype end group for non-group")
  8460  		}
  8461  		if fieldNum <= 0 {
  8462  			return fmt.Errorf("proto: ClusterWorkflows: illegal tag %d (wire type %d)", fieldNum, wire)
  8463  		}
  8464  		switch fieldNum {
  8465  		case 1:
  8466  			if wireType != 2 {
  8467  				return fmt.Errorf("proto: wrong wireType = %d for field Workflows", wireType)
  8468  			}
  8469  			var msglen int
  8470  			for shift := uint(0); ; shift += 7 {
  8471  				if shift >= 64 {
  8472  					return ErrIntOverflow
  8473  				}
  8474  				if iNdEx >= l {
  8475  					return io.ErrUnexpectedEOF
  8476  				}
  8477  				b := dAtA[iNdEx]
  8478  				iNdEx++
  8479  				msglen |= int(b&0x7F) << shift
  8480  				if b < 0x80 {
  8481  					break
  8482  				}
  8483  			}
  8484  			if msglen < 0 {
  8485  				return ErrInvalidLength
  8486  			}
  8487  			postIndex := iNdEx + msglen
  8488  			if postIndex < 0 {
  8489  				return ErrInvalidLength
  8490  			}
  8491  			if postIndex > l {
  8492  				return io.ErrUnexpectedEOF
  8493  			}
  8494  			m.Workflows = append(m.Workflows, &Workflow{})
  8495  			if err := m.Workflows[len(m.Workflows)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8496  				return err
  8497  			}
  8498  			iNdEx = postIndex
  8499  		case 2:
  8500  			if wireType != 2 {
  8501  				return fmt.Errorf("proto: wrong wireType = %d for field Warnings", wireType)
  8502  			}
  8503  			var stringLen uint64
  8504  			for shift := uint(0); ; shift += 7 {
  8505  				if shift >= 64 {
  8506  					return ErrIntOverflow
  8507  				}
  8508  				if iNdEx >= l {
  8509  					return io.ErrUnexpectedEOF
  8510  				}
  8511  				b := dAtA[iNdEx]
  8512  				iNdEx++
  8513  				stringLen |= uint64(b&0x7F) << shift
  8514  				if b < 0x80 {
  8515  					break
  8516  				}
  8517  			}
  8518  			intStringLen := int(stringLen)
  8519  			if intStringLen < 0 {
  8520  				return ErrInvalidLength
  8521  			}
  8522  			postIndex := iNdEx + intStringLen
  8523  			if postIndex < 0 {
  8524  				return ErrInvalidLength
  8525  			}
  8526  			if postIndex > l {
  8527  				return io.ErrUnexpectedEOF
  8528  			}
  8529  			m.Warnings = append(m.Warnings, string(dAtA[iNdEx:postIndex]))
  8530  			iNdEx = postIndex
  8531  		default:
  8532  			iNdEx = preIndex
  8533  			skippy, err := skip(dAtA[iNdEx:])
  8534  			if err != nil {
  8535  				return err
  8536  			}
  8537  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8538  				return ErrInvalidLength
  8539  			}
  8540  			if (iNdEx + skippy) > l {
  8541  				return io.ErrUnexpectedEOF
  8542  			}
  8543  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8544  			iNdEx += skippy
  8545  		}
  8546  	}
  8547  
  8548  	if iNdEx > l {
  8549  		return io.ErrUnexpectedEOF
  8550  	}
  8551  	return nil
  8552  }
  8553  func (m *Keyspace) UnmarshalVT(dAtA []byte) error {
  8554  	l := len(dAtA)
  8555  	iNdEx := 0
  8556  	for iNdEx < l {
  8557  		preIndex := iNdEx
  8558  		var wire uint64
  8559  		for shift := uint(0); ; shift += 7 {
  8560  			if shift >= 64 {
  8561  				return ErrIntOverflow
  8562  			}
  8563  			if iNdEx >= l {
  8564  				return io.ErrUnexpectedEOF
  8565  			}
  8566  			b := dAtA[iNdEx]
  8567  			iNdEx++
  8568  			wire |= uint64(b&0x7F) << shift
  8569  			if b < 0x80 {
  8570  				break
  8571  			}
  8572  		}
  8573  		fieldNum := int32(wire >> 3)
  8574  		wireType := int(wire & 0x7)
  8575  		if wireType == 4 {
  8576  			return fmt.Errorf("proto: Keyspace: wiretype end group for non-group")
  8577  		}
  8578  		if fieldNum <= 0 {
  8579  			return fmt.Errorf("proto: Keyspace: illegal tag %d (wire type %d)", fieldNum, wire)
  8580  		}
  8581  		switch fieldNum {
  8582  		case 1:
  8583  			if wireType != 2 {
  8584  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  8585  			}
  8586  			var msglen int
  8587  			for shift := uint(0); ; shift += 7 {
  8588  				if shift >= 64 {
  8589  					return ErrIntOverflow
  8590  				}
  8591  				if iNdEx >= l {
  8592  					return io.ErrUnexpectedEOF
  8593  				}
  8594  				b := dAtA[iNdEx]
  8595  				iNdEx++
  8596  				msglen |= int(b&0x7F) << shift
  8597  				if b < 0x80 {
  8598  					break
  8599  				}
  8600  			}
  8601  			if msglen < 0 {
  8602  				return ErrInvalidLength
  8603  			}
  8604  			postIndex := iNdEx + msglen
  8605  			if postIndex < 0 {
  8606  				return ErrInvalidLength
  8607  			}
  8608  			if postIndex > l {
  8609  				return io.ErrUnexpectedEOF
  8610  			}
  8611  			if m.Cluster == nil {
  8612  				m.Cluster = &Cluster{}
  8613  			}
  8614  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8615  				return err
  8616  			}
  8617  			iNdEx = postIndex
  8618  		case 2:
  8619  			if wireType != 2 {
  8620  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
  8621  			}
  8622  			var msglen int
  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  				msglen |= int(b&0x7F) << shift
  8633  				if b < 0x80 {
  8634  					break
  8635  				}
  8636  			}
  8637  			if msglen < 0 {
  8638  				return ErrInvalidLength
  8639  			}
  8640  			postIndex := iNdEx + msglen
  8641  			if postIndex < 0 {
  8642  				return ErrInvalidLength
  8643  			}
  8644  			if postIndex > l {
  8645  				return io.ErrUnexpectedEOF
  8646  			}
  8647  			if m.Keyspace == nil {
  8648  				m.Keyspace = &vtctldata.Keyspace{}
  8649  			}
  8650  			if err := m.Keyspace.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8651  				return err
  8652  			}
  8653  			iNdEx = postIndex
  8654  		case 3:
  8655  			if wireType != 2 {
  8656  				return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
  8657  			}
  8658  			var msglen int
  8659  			for shift := uint(0); ; shift += 7 {
  8660  				if shift >= 64 {
  8661  					return ErrIntOverflow
  8662  				}
  8663  				if iNdEx >= l {
  8664  					return io.ErrUnexpectedEOF
  8665  				}
  8666  				b := dAtA[iNdEx]
  8667  				iNdEx++
  8668  				msglen |= int(b&0x7F) << shift
  8669  				if b < 0x80 {
  8670  					break
  8671  				}
  8672  			}
  8673  			if msglen < 0 {
  8674  				return ErrInvalidLength
  8675  			}
  8676  			postIndex := iNdEx + msglen
  8677  			if postIndex < 0 {
  8678  				return ErrInvalidLength
  8679  			}
  8680  			if postIndex > l {
  8681  				return io.ErrUnexpectedEOF
  8682  			}
  8683  			if m.Shards == nil {
  8684  				m.Shards = make(map[string]*vtctldata.Shard)
  8685  			}
  8686  			var mapkey string
  8687  			var mapvalue *vtctldata.Shard
  8688  			for iNdEx < postIndex {
  8689  				entryPreIndex := iNdEx
  8690  				var wire uint64
  8691  				for shift := uint(0); ; shift += 7 {
  8692  					if shift >= 64 {
  8693  						return ErrIntOverflow
  8694  					}
  8695  					if iNdEx >= l {
  8696  						return io.ErrUnexpectedEOF
  8697  					}
  8698  					b := dAtA[iNdEx]
  8699  					iNdEx++
  8700  					wire |= uint64(b&0x7F) << shift
  8701  					if b < 0x80 {
  8702  						break
  8703  					}
  8704  				}
  8705  				fieldNum := int32(wire >> 3)
  8706  				if fieldNum == 1 {
  8707  					var stringLenmapkey uint64
  8708  					for shift := uint(0); ; shift += 7 {
  8709  						if shift >= 64 {
  8710  							return ErrIntOverflow
  8711  						}
  8712  						if iNdEx >= l {
  8713  							return io.ErrUnexpectedEOF
  8714  						}
  8715  						b := dAtA[iNdEx]
  8716  						iNdEx++
  8717  						stringLenmapkey |= uint64(b&0x7F) << shift
  8718  						if b < 0x80 {
  8719  							break
  8720  						}
  8721  					}
  8722  					intStringLenmapkey := int(stringLenmapkey)
  8723  					if intStringLenmapkey < 0 {
  8724  						return ErrInvalidLength
  8725  					}
  8726  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  8727  					if postStringIndexmapkey < 0 {
  8728  						return ErrInvalidLength
  8729  					}
  8730  					if postStringIndexmapkey > l {
  8731  						return io.ErrUnexpectedEOF
  8732  					}
  8733  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  8734  					iNdEx = postStringIndexmapkey
  8735  				} else if fieldNum == 2 {
  8736  					var mapmsglen int
  8737  					for shift := uint(0); ; shift += 7 {
  8738  						if shift >= 64 {
  8739  							return ErrIntOverflow
  8740  						}
  8741  						if iNdEx >= l {
  8742  							return io.ErrUnexpectedEOF
  8743  						}
  8744  						b := dAtA[iNdEx]
  8745  						iNdEx++
  8746  						mapmsglen |= int(b&0x7F) << shift
  8747  						if b < 0x80 {
  8748  							break
  8749  						}
  8750  					}
  8751  					if mapmsglen < 0 {
  8752  						return ErrInvalidLength
  8753  					}
  8754  					postmsgIndex := iNdEx + mapmsglen
  8755  					if postmsgIndex < 0 {
  8756  						return ErrInvalidLength
  8757  					}
  8758  					if postmsgIndex > l {
  8759  						return io.ErrUnexpectedEOF
  8760  					}
  8761  					mapvalue = &vtctldata.Shard{}
  8762  					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
  8763  						return err
  8764  					}
  8765  					iNdEx = postmsgIndex
  8766  				} else {
  8767  					iNdEx = entryPreIndex
  8768  					skippy, err := skip(dAtA[iNdEx:])
  8769  					if err != nil {
  8770  						return err
  8771  					}
  8772  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  8773  						return ErrInvalidLength
  8774  					}
  8775  					if (iNdEx + skippy) > postIndex {
  8776  						return io.ErrUnexpectedEOF
  8777  					}
  8778  					iNdEx += skippy
  8779  				}
  8780  			}
  8781  			m.Shards[mapkey] = mapvalue
  8782  			iNdEx = postIndex
  8783  		default:
  8784  			iNdEx = preIndex
  8785  			skippy, err := skip(dAtA[iNdEx:])
  8786  			if err != nil {
  8787  				return err
  8788  			}
  8789  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8790  				return ErrInvalidLength
  8791  			}
  8792  			if (iNdEx + skippy) > l {
  8793  				return io.ErrUnexpectedEOF
  8794  			}
  8795  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8796  			iNdEx += skippy
  8797  		}
  8798  	}
  8799  
  8800  	if iNdEx > l {
  8801  		return io.ErrUnexpectedEOF
  8802  	}
  8803  	return nil
  8804  }
  8805  func (m *Schema_ShardTableSize) UnmarshalVT(dAtA []byte) error {
  8806  	l := len(dAtA)
  8807  	iNdEx := 0
  8808  	for iNdEx < l {
  8809  		preIndex := iNdEx
  8810  		var wire uint64
  8811  		for shift := uint(0); ; shift += 7 {
  8812  			if shift >= 64 {
  8813  				return ErrIntOverflow
  8814  			}
  8815  			if iNdEx >= l {
  8816  				return io.ErrUnexpectedEOF
  8817  			}
  8818  			b := dAtA[iNdEx]
  8819  			iNdEx++
  8820  			wire |= uint64(b&0x7F) << shift
  8821  			if b < 0x80 {
  8822  				break
  8823  			}
  8824  		}
  8825  		fieldNum := int32(wire >> 3)
  8826  		wireType := int(wire & 0x7)
  8827  		if wireType == 4 {
  8828  			return fmt.Errorf("proto: Schema_ShardTableSize: wiretype end group for non-group")
  8829  		}
  8830  		if fieldNum <= 0 {
  8831  			return fmt.Errorf("proto: Schema_ShardTableSize: illegal tag %d (wire type %d)", fieldNum, wire)
  8832  		}
  8833  		switch fieldNum {
  8834  		case 1:
  8835  			if wireType != 0 {
  8836  				return fmt.Errorf("proto: wrong wireType = %d for field RowCount", wireType)
  8837  			}
  8838  			m.RowCount = 0
  8839  			for shift := uint(0); ; shift += 7 {
  8840  				if shift >= 64 {
  8841  					return ErrIntOverflow
  8842  				}
  8843  				if iNdEx >= l {
  8844  					return io.ErrUnexpectedEOF
  8845  				}
  8846  				b := dAtA[iNdEx]
  8847  				iNdEx++
  8848  				m.RowCount |= uint64(b&0x7F) << shift
  8849  				if b < 0x80 {
  8850  					break
  8851  				}
  8852  			}
  8853  		case 2:
  8854  			if wireType != 0 {
  8855  				return fmt.Errorf("proto: wrong wireType = %d for field DataLength", wireType)
  8856  			}
  8857  			m.DataLength = 0
  8858  			for shift := uint(0); ; shift += 7 {
  8859  				if shift >= 64 {
  8860  					return ErrIntOverflow
  8861  				}
  8862  				if iNdEx >= l {
  8863  					return io.ErrUnexpectedEOF
  8864  				}
  8865  				b := dAtA[iNdEx]
  8866  				iNdEx++
  8867  				m.DataLength |= uint64(b&0x7F) << shift
  8868  				if b < 0x80 {
  8869  					break
  8870  				}
  8871  			}
  8872  		default:
  8873  			iNdEx = preIndex
  8874  			skippy, err := skip(dAtA[iNdEx:])
  8875  			if err != nil {
  8876  				return err
  8877  			}
  8878  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8879  				return ErrInvalidLength
  8880  			}
  8881  			if (iNdEx + skippy) > l {
  8882  				return io.ErrUnexpectedEOF
  8883  			}
  8884  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8885  			iNdEx += skippy
  8886  		}
  8887  	}
  8888  
  8889  	if iNdEx > l {
  8890  		return io.ErrUnexpectedEOF
  8891  	}
  8892  	return nil
  8893  }
  8894  func (m *Schema_TableSize) UnmarshalVT(dAtA []byte) error {
  8895  	l := len(dAtA)
  8896  	iNdEx := 0
  8897  	for iNdEx < l {
  8898  		preIndex := iNdEx
  8899  		var wire uint64
  8900  		for shift := uint(0); ; shift += 7 {
  8901  			if shift >= 64 {
  8902  				return ErrIntOverflow
  8903  			}
  8904  			if iNdEx >= l {
  8905  				return io.ErrUnexpectedEOF
  8906  			}
  8907  			b := dAtA[iNdEx]
  8908  			iNdEx++
  8909  			wire |= uint64(b&0x7F) << shift
  8910  			if b < 0x80 {
  8911  				break
  8912  			}
  8913  		}
  8914  		fieldNum := int32(wire >> 3)
  8915  		wireType := int(wire & 0x7)
  8916  		if wireType == 4 {
  8917  			return fmt.Errorf("proto: Schema_TableSize: wiretype end group for non-group")
  8918  		}
  8919  		if fieldNum <= 0 {
  8920  			return fmt.Errorf("proto: Schema_TableSize: illegal tag %d (wire type %d)", fieldNum, wire)
  8921  		}
  8922  		switch fieldNum {
  8923  		case 1:
  8924  			if wireType != 0 {
  8925  				return fmt.Errorf("proto: wrong wireType = %d for field RowCount", wireType)
  8926  			}
  8927  			m.RowCount = 0
  8928  			for shift := uint(0); ; shift += 7 {
  8929  				if shift >= 64 {
  8930  					return ErrIntOverflow
  8931  				}
  8932  				if iNdEx >= l {
  8933  					return io.ErrUnexpectedEOF
  8934  				}
  8935  				b := dAtA[iNdEx]
  8936  				iNdEx++
  8937  				m.RowCount |= uint64(b&0x7F) << shift
  8938  				if b < 0x80 {
  8939  					break
  8940  				}
  8941  			}
  8942  		case 2:
  8943  			if wireType != 0 {
  8944  				return fmt.Errorf("proto: wrong wireType = %d for field DataLength", wireType)
  8945  			}
  8946  			m.DataLength = 0
  8947  			for shift := uint(0); ; shift += 7 {
  8948  				if shift >= 64 {
  8949  					return ErrIntOverflow
  8950  				}
  8951  				if iNdEx >= l {
  8952  					return io.ErrUnexpectedEOF
  8953  				}
  8954  				b := dAtA[iNdEx]
  8955  				iNdEx++
  8956  				m.DataLength |= uint64(b&0x7F) << shift
  8957  				if b < 0x80 {
  8958  					break
  8959  				}
  8960  			}
  8961  		case 3:
  8962  			if wireType != 2 {
  8963  				return fmt.Errorf("proto: wrong wireType = %d for field ByShard", wireType)
  8964  			}
  8965  			var msglen int
  8966  			for shift := uint(0); ; shift += 7 {
  8967  				if shift >= 64 {
  8968  					return ErrIntOverflow
  8969  				}
  8970  				if iNdEx >= l {
  8971  					return io.ErrUnexpectedEOF
  8972  				}
  8973  				b := dAtA[iNdEx]
  8974  				iNdEx++
  8975  				msglen |= int(b&0x7F) << shift
  8976  				if b < 0x80 {
  8977  					break
  8978  				}
  8979  			}
  8980  			if msglen < 0 {
  8981  				return ErrInvalidLength
  8982  			}
  8983  			postIndex := iNdEx + msglen
  8984  			if postIndex < 0 {
  8985  				return ErrInvalidLength
  8986  			}
  8987  			if postIndex > l {
  8988  				return io.ErrUnexpectedEOF
  8989  			}
  8990  			if m.ByShard == nil {
  8991  				m.ByShard = make(map[string]*Schema_ShardTableSize)
  8992  			}
  8993  			var mapkey string
  8994  			var mapvalue *Schema_ShardTableSize
  8995  			for iNdEx < postIndex {
  8996  				entryPreIndex := iNdEx
  8997  				var wire uint64
  8998  				for shift := uint(0); ; shift += 7 {
  8999  					if shift >= 64 {
  9000  						return ErrIntOverflow
  9001  					}
  9002  					if iNdEx >= l {
  9003  						return io.ErrUnexpectedEOF
  9004  					}
  9005  					b := dAtA[iNdEx]
  9006  					iNdEx++
  9007  					wire |= uint64(b&0x7F) << shift
  9008  					if b < 0x80 {
  9009  						break
  9010  					}
  9011  				}
  9012  				fieldNum := int32(wire >> 3)
  9013  				if fieldNum == 1 {
  9014  					var stringLenmapkey uint64
  9015  					for shift := uint(0); ; shift += 7 {
  9016  						if shift >= 64 {
  9017  							return ErrIntOverflow
  9018  						}
  9019  						if iNdEx >= l {
  9020  							return io.ErrUnexpectedEOF
  9021  						}
  9022  						b := dAtA[iNdEx]
  9023  						iNdEx++
  9024  						stringLenmapkey |= uint64(b&0x7F) << shift
  9025  						if b < 0x80 {
  9026  							break
  9027  						}
  9028  					}
  9029  					intStringLenmapkey := int(stringLenmapkey)
  9030  					if intStringLenmapkey < 0 {
  9031  						return ErrInvalidLength
  9032  					}
  9033  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  9034  					if postStringIndexmapkey < 0 {
  9035  						return ErrInvalidLength
  9036  					}
  9037  					if postStringIndexmapkey > l {
  9038  						return io.ErrUnexpectedEOF
  9039  					}
  9040  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  9041  					iNdEx = postStringIndexmapkey
  9042  				} else if fieldNum == 2 {
  9043  					var mapmsglen int
  9044  					for shift := uint(0); ; shift += 7 {
  9045  						if shift >= 64 {
  9046  							return ErrIntOverflow
  9047  						}
  9048  						if iNdEx >= l {
  9049  							return io.ErrUnexpectedEOF
  9050  						}
  9051  						b := dAtA[iNdEx]
  9052  						iNdEx++
  9053  						mapmsglen |= int(b&0x7F) << shift
  9054  						if b < 0x80 {
  9055  							break
  9056  						}
  9057  					}
  9058  					if mapmsglen < 0 {
  9059  						return ErrInvalidLength
  9060  					}
  9061  					postmsgIndex := iNdEx + mapmsglen
  9062  					if postmsgIndex < 0 {
  9063  						return ErrInvalidLength
  9064  					}
  9065  					if postmsgIndex > l {
  9066  						return io.ErrUnexpectedEOF
  9067  					}
  9068  					mapvalue = &Schema_ShardTableSize{}
  9069  					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
  9070  						return err
  9071  					}
  9072  					iNdEx = postmsgIndex
  9073  				} else {
  9074  					iNdEx = entryPreIndex
  9075  					skippy, err := skip(dAtA[iNdEx:])
  9076  					if err != nil {
  9077  						return err
  9078  					}
  9079  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  9080  						return ErrInvalidLength
  9081  					}
  9082  					if (iNdEx + skippy) > postIndex {
  9083  						return io.ErrUnexpectedEOF
  9084  					}
  9085  					iNdEx += skippy
  9086  				}
  9087  			}
  9088  			m.ByShard[mapkey] = mapvalue
  9089  			iNdEx = postIndex
  9090  		default:
  9091  			iNdEx = preIndex
  9092  			skippy, err := skip(dAtA[iNdEx:])
  9093  			if err != nil {
  9094  				return err
  9095  			}
  9096  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9097  				return ErrInvalidLength
  9098  			}
  9099  			if (iNdEx + skippy) > l {
  9100  				return io.ErrUnexpectedEOF
  9101  			}
  9102  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9103  			iNdEx += skippy
  9104  		}
  9105  	}
  9106  
  9107  	if iNdEx > l {
  9108  		return io.ErrUnexpectedEOF
  9109  	}
  9110  	return nil
  9111  }
  9112  func (m *Schema) UnmarshalVT(dAtA []byte) error {
  9113  	l := len(dAtA)
  9114  	iNdEx := 0
  9115  	for iNdEx < l {
  9116  		preIndex := iNdEx
  9117  		var wire uint64
  9118  		for shift := uint(0); ; shift += 7 {
  9119  			if shift >= 64 {
  9120  				return ErrIntOverflow
  9121  			}
  9122  			if iNdEx >= l {
  9123  				return io.ErrUnexpectedEOF
  9124  			}
  9125  			b := dAtA[iNdEx]
  9126  			iNdEx++
  9127  			wire |= uint64(b&0x7F) << shift
  9128  			if b < 0x80 {
  9129  				break
  9130  			}
  9131  		}
  9132  		fieldNum := int32(wire >> 3)
  9133  		wireType := int(wire & 0x7)
  9134  		if wireType == 4 {
  9135  			return fmt.Errorf("proto: Schema: wiretype end group for non-group")
  9136  		}
  9137  		if fieldNum <= 0 {
  9138  			return fmt.Errorf("proto: Schema: illegal tag %d (wire type %d)", fieldNum, wire)
  9139  		}
  9140  		switch fieldNum {
  9141  		case 1:
  9142  			if wireType != 2 {
  9143  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  9144  			}
  9145  			var msglen int
  9146  			for shift := uint(0); ; shift += 7 {
  9147  				if shift >= 64 {
  9148  					return ErrIntOverflow
  9149  				}
  9150  				if iNdEx >= l {
  9151  					return io.ErrUnexpectedEOF
  9152  				}
  9153  				b := dAtA[iNdEx]
  9154  				iNdEx++
  9155  				msglen |= int(b&0x7F) << shift
  9156  				if b < 0x80 {
  9157  					break
  9158  				}
  9159  			}
  9160  			if msglen < 0 {
  9161  				return ErrInvalidLength
  9162  			}
  9163  			postIndex := iNdEx + msglen
  9164  			if postIndex < 0 {
  9165  				return ErrInvalidLength
  9166  			}
  9167  			if postIndex > l {
  9168  				return io.ErrUnexpectedEOF
  9169  			}
  9170  			if m.Cluster == nil {
  9171  				m.Cluster = &Cluster{}
  9172  			}
  9173  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9174  				return err
  9175  			}
  9176  			iNdEx = postIndex
  9177  		case 2:
  9178  			if wireType != 2 {
  9179  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
  9180  			}
  9181  			var stringLen uint64
  9182  			for shift := uint(0); ; shift += 7 {
  9183  				if shift >= 64 {
  9184  					return ErrIntOverflow
  9185  				}
  9186  				if iNdEx >= l {
  9187  					return io.ErrUnexpectedEOF
  9188  				}
  9189  				b := dAtA[iNdEx]
  9190  				iNdEx++
  9191  				stringLen |= uint64(b&0x7F) << shift
  9192  				if b < 0x80 {
  9193  					break
  9194  				}
  9195  			}
  9196  			intStringLen := int(stringLen)
  9197  			if intStringLen < 0 {
  9198  				return ErrInvalidLength
  9199  			}
  9200  			postIndex := iNdEx + intStringLen
  9201  			if postIndex < 0 {
  9202  				return ErrInvalidLength
  9203  			}
  9204  			if postIndex > l {
  9205  				return io.ErrUnexpectedEOF
  9206  			}
  9207  			m.Keyspace = string(dAtA[iNdEx:postIndex])
  9208  			iNdEx = postIndex
  9209  		case 3:
  9210  			if wireType != 2 {
  9211  				return fmt.Errorf("proto: wrong wireType = %d for field TableDefinitions", wireType)
  9212  			}
  9213  			var msglen int
  9214  			for shift := uint(0); ; shift += 7 {
  9215  				if shift >= 64 {
  9216  					return ErrIntOverflow
  9217  				}
  9218  				if iNdEx >= l {
  9219  					return io.ErrUnexpectedEOF
  9220  				}
  9221  				b := dAtA[iNdEx]
  9222  				iNdEx++
  9223  				msglen |= int(b&0x7F) << shift
  9224  				if b < 0x80 {
  9225  					break
  9226  				}
  9227  			}
  9228  			if msglen < 0 {
  9229  				return ErrInvalidLength
  9230  			}
  9231  			postIndex := iNdEx + msglen
  9232  			if postIndex < 0 {
  9233  				return ErrInvalidLength
  9234  			}
  9235  			if postIndex > l {
  9236  				return io.ErrUnexpectedEOF
  9237  			}
  9238  			m.TableDefinitions = append(m.TableDefinitions, &tabletmanagerdata.TableDefinition{})
  9239  			if err := m.TableDefinitions[len(m.TableDefinitions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9240  				return err
  9241  			}
  9242  			iNdEx = postIndex
  9243  		case 4:
  9244  			if wireType != 2 {
  9245  				return fmt.Errorf("proto: wrong wireType = %d for field TableSizes", wireType)
  9246  			}
  9247  			var msglen int
  9248  			for shift := uint(0); ; shift += 7 {
  9249  				if shift >= 64 {
  9250  					return ErrIntOverflow
  9251  				}
  9252  				if iNdEx >= l {
  9253  					return io.ErrUnexpectedEOF
  9254  				}
  9255  				b := dAtA[iNdEx]
  9256  				iNdEx++
  9257  				msglen |= int(b&0x7F) << shift
  9258  				if b < 0x80 {
  9259  					break
  9260  				}
  9261  			}
  9262  			if msglen < 0 {
  9263  				return ErrInvalidLength
  9264  			}
  9265  			postIndex := iNdEx + msglen
  9266  			if postIndex < 0 {
  9267  				return ErrInvalidLength
  9268  			}
  9269  			if postIndex > l {
  9270  				return io.ErrUnexpectedEOF
  9271  			}
  9272  			if m.TableSizes == nil {
  9273  				m.TableSizes = make(map[string]*Schema_TableSize)
  9274  			}
  9275  			var mapkey string
  9276  			var mapvalue *Schema_TableSize
  9277  			for iNdEx < postIndex {
  9278  				entryPreIndex := iNdEx
  9279  				var wire uint64
  9280  				for shift := uint(0); ; shift += 7 {
  9281  					if shift >= 64 {
  9282  						return ErrIntOverflow
  9283  					}
  9284  					if iNdEx >= l {
  9285  						return io.ErrUnexpectedEOF
  9286  					}
  9287  					b := dAtA[iNdEx]
  9288  					iNdEx++
  9289  					wire |= uint64(b&0x7F) << shift
  9290  					if b < 0x80 {
  9291  						break
  9292  					}
  9293  				}
  9294  				fieldNum := int32(wire >> 3)
  9295  				if fieldNum == 1 {
  9296  					var stringLenmapkey uint64
  9297  					for shift := uint(0); ; shift += 7 {
  9298  						if shift >= 64 {
  9299  							return ErrIntOverflow
  9300  						}
  9301  						if iNdEx >= l {
  9302  							return io.ErrUnexpectedEOF
  9303  						}
  9304  						b := dAtA[iNdEx]
  9305  						iNdEx++
  9306  						stringLenmapkey |= uint64(b&0x7F) << shift
  9307  						if b < 0x80 {
  9308  							break
  9309  						}
  9310  					}
  9311  					intStringLenmapkey := int(stringLenmapkey)
  9312  					if intStringLenmapkey < 0 {
  9313  						return ErrInvalidLength
  9314  					}
  9315  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  9316  					if postStringIndexmapkey < 0 {
  9317  						return ErrInvalidLength
  9318  					}
  9319  					if postStringIndexmapkey > l {
  9320  						return io.ErrUnexpectedEOF
  9321  					}
  9322  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  9323  					iNdEx = postStringIndexmapkey
  9324  				} else if fieldNum == 2 {
  9325  					var mapmsglen int
  9326  					for shift := uint(0); ; shift += 7 {
  9327  						if shift >= 64 {
  9328  							return ErrIntOverflow
  9329  						}
  9330  						if iNdEx >= l {
  9331  							return io.ErrUnexpectedEOF
  9332  						}
  9333  						b := dAtA[iNdEx]
  9334  						iNdEx++
  9335  						mapmsglen |= int(b&0x7F) << shift
  9336  						if b < 0x80 {
  9337  							break
  9338  						}
  9339  					}
  9340  					if mapmsglen < 0 {
  9341  						return ErrInvalidLength
  9342  					}
  9343  					postmsgIndex := iNdEx + mapmsglen
  9344  					if postmsgIndex < 0 {
  9345  						return ErrInvalidLength
  9346  					}
  9347  					if postmsgIndex > l {
  9348  						return io.ErrUnexpectedEOF
  9349  					}
  9350  					mapvalue = &Schema_TableSize{}
  9351  					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
  9352  						return err
  9353  					}
  9354  					iNdEx = postmsgIndex
  9355  				} else {
  9356  					iNdEx = entryPreIndex
  9357  					skippy, err := skip(dAtA[iNdEx:])
  9358  					if err != nil {
  9359  						return err
  9360  					}
  9361  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  9362  						return ErrInvalidLength
  9363  					}
  9364  					if (iNdEx + skippy) > postIndex {
  9365  						return io.ErrUnexpectedEOF
  9366  					}
  9367  					iNdEx += skippy
  9368  				}
  9369  			}
  9370  			m.TableSizes[mapkey] = mapvalue
  9371  			iNdEx = postIndex
  9372  		default:
  9373  			iNdEx = preIndex
  9374  			skippy, err := skip(dAtA[iNdEx:])
  9375  			if err != nil {
  9376  				return err
  9377  			}
  9378  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9379  				return ErrInvalidLength
  9380  			}
  9381  			if (iNdEx + skippy) > l {
  9382  				return io.ErrUnexpectedEOF
  9383  			}
  9384  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9385  			iNdEx += skippy
  9386  		}
  9387  	}
  9388  
  9389  	if iNdEx > l {
  9390  		return io.ErrUnexpectedEOF
  9391  	}
  9392  	return nil
  9393  }
  9394  func (m *Shard) UnmarshalVT(dAtA []byte) error {
  9395  	l := len(dAtA)
  9396  	iNdEx := 0
  9397  	for iNdEx < l {
  9398  		preIndex := iNdEx
  9399  		var wire uint64
  9400  		for shift := uint(0); ; shift += 7 {
  9401  			if shift >= 64 {
  9402  				return ErrIntOverflow
  9403  			}
  9404  			if iNdEx >= l {
  9405  				return io.ErrUnexpectedEOF
  9406  			}
  9407  			b := dAtA[iNdEx]
  9408  			iNdEx++
  9409  			wire |= uint64(b&0x7F) << shift
  9410  			if b < 0x80 {
  9411  				break
  9412  			}
  9413  		}
  9414  		fieldNum := int32(wire >> 3)
  9415  		wireType := int(wire & 0x7)
  9416  		if wireType == 4 {
  9417  			return fmt.Errorf("proto: Shard: wiretype end group for non-group")
  9418  		}
  9419  		if fieldNum <= 0 {
  9420  			return fmt.Errorf("proto: Shard: illegal tag %d (wire type %d)", fieldNum, wire)
  9421  		}
  9422  		switch fieldNum {
  9423  		case 1:
  9424  			if wireType != 2 {
  9425  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  9426  			}
  9427  			var msglen int
  9428  			for shift := uint(0); ; shift += 7 {
  9429  				if shift >= 64 {
  9430  					return ErrIntOverflow
  9431  				}
  9432  				if iNdEx >= l {
  9433  					return io.ErrUnexpectedEOF
  9434  				}
  9435  				b := dAtA[iNdEx]
  9436  				iNdEx++
  9437  				msglen |= int(b&0x7F) << shift
  9438  				if b < 0x80 {
  9439  					break
  9440  				}
  9441  			}
  9442  			if msglen < 0 {
  9443  				return ErrInvalidLength
  9444  			}
  9445  			postIndex := iNdEx + msglen
  9446  			if postIndex < 0 {
  9447  				return ErrInvalidLength
  9448  			}
  9449  			if postIndex > l {
  9450  				return io.ErrUnexpectedEOF
  9451  			}
  9452  			if m.Cluster == nil {
  9453  				m.Cluster = &Cluster{}
  9454  			}
  9455  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9456  				return err
  9457  			}
  9458  			iNdEx = postIndex
  9459  		case 2:
  9460  			if wireType != 2 {
  9461  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
  9462  			}
  9463  			var msglen int
  9464  			for shift := uint(0); ; shift += 7 {
  9465  				if shift >= 64 {
  9466  					return ErrIntOverflow
  9467  				}
  9468  				if iNdEx >= l {
  9469  					return io.ErrUnexpectedEOF
  9470  				}
  9471  				b := dAtA[iNdEx]
  9472  				iNdEx++
  9473  				msglen |= int(b&0x7F) << shift
  9474  				if b < 0x80 {
  9475  					break
  9476  				}
  9477  			}
  9478  			if msglen < 0 {
  9479  				return ErrInvalidLength
  9480  			}
  9481  			postIndex := iNdEx + msglen
  9482  			if postIndex < 0 {
  9483  				return ErrInvalidLength
  9484  			}
  9485  			if postIndex > l {
  9486  				return io.ErrUnexpectedEOF
  9487  			}
  9488  			if m.Shard == nil {
  9489  				m.Shard = &vtctldata.Shard{}
  9490  			}
  9491  			if err := m.Shard.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9492  				return err
  9493  			}
  9494  			iNdEx = postIndex
  9495  		default:
  9496  			iNdEx = preIndex
  9497  			skippy, err := skip(dAtA[iNdEx:])
  9498  			if err != nil {
  9499  				return err
  9500  			}
  9501  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9502  				return ErrInvalidLength
  9503  			}
  9504  			if (iNdEx + skippy) > l {
  9505  				return io.ErrUnexpectedEOF
  9506  			}
  9507  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9508  			iNdEx += skippy
  9509  		}
  9510  	}
  9511  
  9512  	if iNdEx > l {
  9513  		return io.ErrUnexpectedEOF
  9514  	}
  9515  	return nil
  9516  }
  9517  func (m *SrvVSchema) UnmarshalVT(dAtA []byte) error {
  9518  	l := len(dAtA)
  9519  	iNdEx := 0
  9520  	for iNdEx < l {
  9521  		preIndex := iNdEx
  9522  		var wire uint64
  9523  		for shift := uint(0); ; shift += 7 {
  9524  			if shift >= 64 {
  9525  				return ErrIntOverflow
  9526  			}
  9527  			if iNdEx >= l {
  9528  				return io.ErrUnexpectedEOF
  9529  			}
  9530  			b := dAtA[iNdEx]
  9531  			iNdEx++
  9532  			wire |= uint64(b&0x7F) << shift
  9533  			if b < 0x80 {
  9534  				break
  9535  			}
  9536  		}
  9537  		fieldNum := int32(wire >> 3)
  9538  		wireType := int(wire & 0x7)
  9539  		if wireType == 4 {
  9540  			return fmt.Errorf("proto: SrvVSchema: wiretype end group for non-group")
  9541  		}
  9542  		if fieldNum <= 0 {
  9543  			return fmt.Errorf("proto: SrvVSchema: illegal tag %d (wire type %d)", fieldNum, wire)
  9544  		}
  9545  		switch fieldNum {
  9546  		case 1:
  9547  			if wireType != 2 {
  9548  				return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType)
  9549  			}
  9550  			var stringLen uint64
  9551  			for shift := uint(0); ; shift += 7 {
  9552  				if shift >= 64 {
  9553  					return ErrIntOverflow
  9554  				}
  9555  				if iNdEx >= l {
  9556  					return io.ErrUnexpectedEOF
  9557  				}
  9558  				b := dAtA[iNdEx]
  9559  				iNdEx++
  9560  				stringLen |= uint64(b&0x7F) << shift
  9561  				if b < 0x80 {
  9562  					break
  9563  				}
  9564  			}
  9565  			intStringLen := int(stringLen)
  9566  			if intStringLen < 0 {
  9567  				return ErrInvalidLength
  9568  			}
  9569  			postIndex := iNdEx + intStringLen
  9570  			if postIndex < 0 {
  9571  				return ErrInvalidLength
  9572  			}
  9573  			if postIndex > l {
  9574  				return io.ErrUnexpectedEOF
  9575  			}
  9576  			m.Cell = string(dAtA[iNdEx:postIndex])
  9577  			iNdEx = postIndex
  9578  		case 2:
  9579  			if wireType != 2 {
  9580  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  9581  			}
  9582  			var msglen int
  9583  			for shift := uint(0); ; shift += 7 {
  9584  				if shift >= 64 {
  9585  					return ErrIntOverflow
  9586  				}
  9587  				if iNdEx >= l {
  9588  					return io.ErrUnexpectedEOF
  9589  				}
  9590  				b := dAtA[iNdEx]
  9591  				iNdEx++
  9592  				msglen |= int(b&0x7F) << shift
  9593  				if b < 0x80 {
  9594  					break
  9595  				}
  9596  			}
  9597  			if msglen < 0 {
  9598  				return ErrInvalidLength
  9599  			}
  9600  			postIndex := iNdEx + msglen
  9601  			if postIndex < 0 {
  9602  				return ErrInvalidLength
  9603  			}
  9604  			if postIndex > l {
  9605  				return io.ErrUnexpectedEOF
  9606  			}
  9607  			if m.Cluster == nil {
  9608  				m.Cluster = &Cluster{}
  9609  			}
  9610  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9611  				return err
  9612  			}
  9613  			iNdEx = postIndex
  9614  		case 3:
  9615  			if wireType != 2 {
  9616  				return fmt.Errorf("proto: wrong wireType = %d for field SrvVSchema", wireType)
  9617  			}
  9618  			var msglen int
  9619  			for shift := uint(0); ; shift += 7 {
  9620  				if shift >= 64 {
  9621  					return ErrIntOverflow
  9622  				}
  9623  				if iNdEx >= l {
  9624  					return io.ErrUnexpectedEOF
  9625  				}
  9626  				b := dAtA[iNdEx]
  9627  				iNdEx++
  9628  				msglen |= int(b&0x7F) << shift
  9629  				if b < 0x80 {
  9630  					break
  9631  				}
  9632  			}
  9633  			if msglen < 0 {
  9634  				return ErrInvalidLength
  9635  			}
  9636  			postIndex := iNdEx + msglen
  9637  			if postIndex < 0 {
  9638  				return ErrInvalidLength
  9639  			}
  9640  			if postIndex > l {
  9641  				return io.ErrUnexpectedEOF
  9642  			}
  9643  			if m.SrvVSchema == nil {
  9644  				m.SrvVSchema = &vschema.SrvVSchema{}
  9645  			}
  9646  			if err := m.SrvVSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9647  				return err
  9648  			}
  9649  			iNdEx = postIndex
  9650  		default:
  9651  			iNdEx = preIndex
  9652  			skippy, err := skip(dAtA[iNdEx:])
  9653  			if err != nil {
  9654  				return err
  9655  			}
  9656  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9657  				return ErrInvalidLength
  9658  			}
  9659  			if (iNdEx + skippy) > l {
  9660  				return io.ErrUnexpectedEOF
  9661  			}
  9662  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9663  			iNdEx += skippy
  9664  		}
  9665  	}
  9666  
  9667  	if iNdEx > l {
  9668  		return io.ErrUnexpectedEOF
  9669  	}
  9670  	return nil
  9671  }
  9672  func (m *Tablet) UnmarshalVT(dAtA []byte) error {
  9673  	l := len(dAtA)
  9674  	iNdEx := 0
  9675  	for iNdEx < l {
  9676  		preIndex := iNdEx
  9677  		var wire uint64
  9678  		for shift := uint(0); ; shift += 7 {
  9679  			if shift >= 64 {
  9680  				return ErrIntOverflow
  9681  			}
  9682  			if iNdEx >= l {
  9683  				return io.ErrUnexpectedEOF
  9684  			}
  9685  			b := dAtA[iNdEx]
  9686  			iNdEx++
  9687  			wire |= uint64(b&0x7F) << shift
  9688  			if b < 0x80 {
  9689  				break
  9690  			}
  9691  		}
  9692  		fieldNum := int32(wire >> 3)
  9693  		wireType := int(wire & 0x7)
  9694  		if wireType == 4 {
  9695  			return fmt.Errorf("proto: Tablet: wiretype end group for non-group")
  9696  		}
  9697  		if fieldNum <= 0 {
  9698  			return fmt.Errorf("proto: Tablet: illegal tag %d (wire type %d)", fieldNum, wire)
  9699  		}
  9700  		switch fieldNum {
  9701  		case 1:
  9702  			if wireType != 2 {
  9703  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  9704  			}
  9705  			var msglen int
  9706  			for shift := uint(0); ; shift += 7 {
  9707  				if shift >= 64 {
  9708  					return ErrIntOverflow
  9709  				}
  9710  				if iNdEx >= l {
  9711  					return io.ErrUnexpectedEOF
  9712  				}
  9713  				b := dAtA[iNdEx]
  9714  				iNdEx++
  9715  				msglen |= int(b&0x7F) << shift
  9716  				if b < 0x80 {
  9717  					break
  9718  				}
  9719  			}
  9720  			if msglen < 0 {
  9721  				return ErrInvalidLength
  9722  			}
  9723  			postIndex := iNdEx + msglen
  9724  			if postIndex < 0 {
  9725  				return ErrInvalidLength
  9726  			}
  9727  			if postIndex > l {
  9728  				return io.ErrUnexpectedEOF
  9729  			}
  9730  			if m.Cluster == nil {
  9731  				m.Cluster = &Cluster{}
  9732  			}
  9733  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9734  				return err
  9735  			}
  9736  			iNdEx = postIndex
  9737  		case 2:
  9738  			if wireType != 2 {
  9739  				return fmt.Errorf("proto: wrong wireType = %d for field Tablet", wireType)
  9740  			}
  9741  			var msglen int
  9742  			for shift := uint(0); ; shift += 7 {
  9743  				if shift >= 64 {
  9744  					return ErrIntOverflow
  9745  				}
  9746  				if iNdEx >= l {
  9747  					return io.ErrUnexpectedEOF
  9748  				}
  9749  				b := dAtA[iNdEx]
  9750  				iNdEx++
  9751  				msglen |= int(b&0x7F) << shift
  9752  				if b < 0x80 {
  9753  					break
  9754  				}
  9755  			}
  9756  			if msglen < 0 {
  9757  				return ErrInvalidLength
  9758  			}
  9759  			postIndex := iNdEx + msglen
  9760  			if postIndex < 0 {
  9761  				return ErrInvalidLength
  9762  			}
  9763  			if postIndex > l {
  9764  				return io.ErrUnexpectedEOF
  9765  			}
  9766  			if m.Tablet == nil {
  9767  				m.Tablet = &topodata.Tablet{}
  9768  			}
  9769  			if err := m.Tablet.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9770  				return err
  9771  			}
  9772  			iNdEx = postIndex
  9773  		case 3:
  9774  			if wireType != 0 {
  9775  				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
  9776  			}
  9777  			m.State = 0
  9778  			for shift := uint(0); ; shift += 7 {
  9779  				if shift >= 64 {
  9780  					return ErrIntOverflow
  9781  				}
  9782  				if iNdEx >= l {
  9783  					return io.ErrUnexpectedEOF
  9784  				}
  9785  				b := dAtA[iNdEx]
  9786  				iNdEx++
  9787  				m.State |= Tablet_ServingState(b&0x7F) << shift
  9788  				if b < 0x80 {
  9789  					break
  9790  				}
  9791  			}
  9792  		case 4:
  9793  			if wireType != 2 {
  9794  				return fmt.Errorf("proto: wrong wireType = %d for field FQDN", wireType)
  9795  			}
  9796  			var stringLen uint64
  9797  			for shift := uint(0); ; shift += 7 {
  9798  				if shift >= 64 {
  9799  					return ErrIntOverflow
  9800  				}
  9801  				if iNdEx >= l {
  9802  					return io.ErrUnexpectedEOF
  9803  				}
  9804  				b := dAtA[iNdEx]
  9805  				iNdEx++
  9806  				stringLen |= uint64(b&0x7F) << shift
  9807  				if b < 0x80 {
  9808  					break
  9809  				}
  9810  			}
  9811  			intStringLen := int(stringLen)
  9812  			if intStringLen < 0 {
  9813  				return ErrInvalidLength
  9814  			}
  9815  			postIndex := iNdEx + intStringLen
  9816  			if postIndex < 0 {
  9817  				return ErrInvalidLength
  9818  			}
  9819  			if postIndex > l {
  9820  				return io.ErrUnexpectedEOF
  9821  			}
  9822  			m.FQDN = string(dAtA[iNdEx:postIndex])
  9823  			iNdEx = postIndex
  9824  		default:
  9825  			iNdEx = preIndex
  9826  			skippy, err := skip(dAtA[iNdEx:])
  9827  			if err != nil {
  9828  				return err
  9829  			}
  9830  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9831  				return ErrInvalidLength
  9832  			}
  9833  			if (iNdEx + skippy) > l {
  9834  				return io.ErrUnexpectedEOF
  9835  			}
  9836  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9837  			iNdEx += skippy
  9838  		}
  9839  	}
  9840  
  9841  	if iNdEx > l {
  9842  		return io.ErrUnexpectedEOF
  9843  	}
  9844  	return nil
  9845  }
  9846  func (m *VSchema) UnmarshalVT(dAtA []byte) error {
  9847  	l := len(dAtA)
  9848  	iNdEx := 0
  9849  	for iNdEx < l {
  9850  		preIndex := iNdEx
  9851  		var wire uint64
  9852  		for shift := uint(0); ; shift += 7 {
  9853  			if shift >= 64 {
  9854  				return ErrIntOverflow
  9855  			}
  9856  			if iNdEx >= l {
  9857  				return io.ErrUnexpectedEOF
  9858  			}
  9859  			b := dAtA[iNdEx]
  9860  			iNdEx++
  9861  			wire |= uint64(b&0x7F) << shift
  9862  			if b < 0x80 {
  9863  				break
  9864  			}
  9865  		}
  9866  		fieldNum := int32(wire >> 3)
  9867  		wireType := int(wire & 0x7)
  9868  		if wireType == 4 {
  9869  			return fmt.Errorf("proto: VSchema: wiretype end group for non-group")
  9870  		}
  9871  		if fieldNum <= 0 {
  9872  			return fmt.Errorf("proto: VSchema: illegal tag %d (wire type %d)", fieldNum, wire)
  9873  		}
  9874  		switch fieldNum {
  9875  		case 1:
  9876  			if wireType != 2 {
  9877  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
  9878  			}
  9879  			var msglen int
  9880  			for shift := uint(0); ; shift += 7 {
  9881  				if shift >= 64 {
  9882  					return ErrIntOverflow
  9883  				}
  9884  				if iNdEx >= l {
  9885  					return io.ErrUnexpectedEOF
  9886  				}
  9887  				b := dAtA[iNdEx]
  9888  				iNdEx++
  9889  				msglen |= int(b&0x7F) << shift
  9890  				if b < 0x80 {
  9891  					break
  9892  				}
  9893  			}
  9894  			if msglen < 0 {
  9895  				return ErrInvalidLength
  9896  			}
  9897  			postIndex := iNdEx + msglen
  9898  			if postIndex < 0 {
  9899  				return ErrInvalidLength
  9900  			}
  9901  			if postIndex > l {
  9902  				return io.ErrUnexpectedEOF
  9903  			}
  9904  			if m.Cluster == nil {
  9905  				m.Cluster = &Cluster{}
  9906  			}
  9907  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9908  				return err
  9909  			}
  9910  			iNdEx = postIndex
  9911  		case 2:
  9912  			if wireType != 2 {
  9913  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  9914  			}
  9915  			var stringLen uint64
  9916  			for shift := uint(0); ; shift += 7 {
  9917  				if shift >= 64 {
  9918  					return ErrIntOverflow
  9919  				}
  9920  				if iNdEx >= l {
  9921  					return io.ErrUnexpectedEOF
  9922  				}
  9923  				b := dAtA[iNdEx]
  9924  				iNdEx++
  9925  				stringLen |= uint64(b&0x7F) << shift
  9926  				if b < 0x80 {
  9927  					break
  9928  				}
  9929  			}
  9930  			intStringLen := int(stringLen)
  9931  			if intStringLen < 0 {
  9932  				return ErrInvalidLength
  9933  			}
  9934  			postIndex := iNdEx + intStringLen
  9935  			if postIndex < 0 {
  9936  				return ErrInvalidLength
  9937  			}
  9938  			if postIndex > l {
  9939  				return io.ErrUnexpectedEOF
  9940  			}
  9941  			m.Name = string(dAtA[iNdEx:postIndex])
  9942  			iNdEx = postIndex
  9943  		case 3:
  9944  			if wireType != 2 {
  9945  				return fmt.Errorf("proto: wrong wireType = %d for field VSchema", wireType)
  9946  			}
  9947  			var msglen int
  9948  			for shift := uint(0); ; shift += 7 {
  9949  				if shift >= 64 {
  9950  					return ErrIntOverflow
  9951  				}
  9952  				if iNdEx >= l {
  9953  					return io.ErrUnexpectedEOF
  9954  				}
  9955  				b := dAtA[iNdEx]
  9956  				iNdEx++
  9957  				msglen |= int(b&0x7F) << shift
  9958  				if b < 0x80 {
  9959  					break
  9960  				}
  9961  			}
  9962  			if msglen < 0 {
  9963  				return ErrInvalidLength
  9964  			}
  9965  			postIndex := iNdEx + msglen
  9966  			if postIndex < 0 {
  9967  				return ErrInvalidLength
  9968  			}
  9969  			if postIndex > l {
  9970  				return io.ErrUnexpectedEOF
  9971  			}
  9972  			if m.VSchema == nil {
  9973  				m.VSchema = &vschema.Keyspace{}
  9974  			}
  9975  			if err := m.VSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9976  				return err
  9977  			}
  9978  			iNdEx = postIndex
  9979  		default:
  9980  			iNdEx = preIndex
  9981  			skippy, err := skip(dAtA[iNdEx:])
  9982  			if err != nil {
  9983  				return err
  9984  			}
  9985  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9986  				return ErrInvalidLength
  9987  			}
  9988  			if (iNdEx + skippy) > l {
  9989  				return io.ErrUnexpectedEOF
  9990  			}
  9991  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9992  			iNdEx += skippy
  9993  		}
  9994  	}
  9995  
  9996  	if iNdEx > l {
  9997  		return io.ErrUnexpectedEOF
  9998  	}
  9999  	return nil
 10000  }
 10001  func (m *Vtctld) UnmarshalVT(dAtA []byte) error {
 10002  	l := len(dAtA)
 10003  	iNdEx := 0
 10004  	for iNdEx < l {
 10005  		preIndex := iNdEx
 10006  		var wire uint64
 10007  		for shift := uint(0); ; shift += 7 {
 10008  			if shift >= 64 {
 10009  				return ErrIntOverflow
 10010  			}
 10011  			if iNdEx >= l {
 10012  				return io.ErrUnexpectedEOF
 10013  			}
 10014  			b := dAtA[iNdEx]
 10015  			iNdEx++
 10016  			wire |= uint64(b&0x7F) << shift
 10017  			if b < 0x80 {
 10018  				break
 10019  			}
 10020  		}
 10021  		fieldNum := int32(wire >> 3)
 10022  		wireType := int(wire & 0x7)
 10023  		if wireType == 4 {
 10024  			return fmt.Errorf("proto: Vtctld: wiretype end group for non-group")
 10025  		}
 10026  		if fieldNum <= 0 {
 10027  			return fmt.Errorf("proto: Vtctld: illegal tag %d (wire type %d)", fieldNum, wire)
 10028  		}
 10029  		switch fieldNum {
 10030  		case 1:
 10031  			if wireType != 2 {
 10032  				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
 10033  			}
 10034  			var stringLen uint64
 10035  			for shift := uint(0); ; shift += 7 {
 10036  				if shift >= 64 {
 10037  					return ErrIntOverflow
 10038  				}
 10039  				if iNdEx >= l {
 10040  					return io.ErrUnexpectedEOF
 10041  				}
 10042  				b := dAtA[iNdEx]
 10043  				iNdEx++
 10044  				stringLen |= uint64(b&0x7F) << shift
 10045  				if b < 0x80 {
 10046  					break
 10047  				}
 10048  			}
 10049  			intStringLen := int(stringLen)
 10050  			if intStringLen < 0 {
 10051  				return ErrInvalidLength
 10052  			}
 10053  			postIndex := iNdEx + intStringLen
 10054  			if postIndex < 0 {
 10055  				return ErrInvalidLength
 10056  			}
 10057  			if postIndex > l {
 10058  				return io.ErrUnexpectedEOF
 10059  			}
 10060  			m.Hostname = string(dAtA[iNdEx:postIndex])
 10061  			iNdEx = postIndex
 10062  		case 2:
 10063  			if wireType != 2 {
 10064  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 10065  			}
 10066  			var msglen int
 10067  			for shift := uint(0); ; shift += 7 {
 10068  				if shift >= 64 {
 10069  					return ErrIntOverflow
 10070  				}
 10071  				if iNdEx >= l {
 10072  					return io.ErrUnexpectedEOF
 10073  				}
 10074  				b := dAtA[iNdEx]
 10075  				iNdEx++
 10076  				msglen |= int(b&0x7F) << shift
 10077  				if b < 0x80 {
 10078  					break
 10079  				}
 10080  			}
 10081  			if msglen < 0 {
 10082  				return ErrInvalidLength
 10083  			}
 10084  			postIndex := iNdEx + msglen
 10085  			if postIndex < 0 {
 10086  				return ErrInvalidLength
 10087  			}
 10088  			if postIndex > l {
 10089  				return io.ErrUnexpectedEOF
 10090  			}
 10091  			if m.Cluster == nil {
 10092  				m.Cluster = &Cluster{}
 10093  			}
 10094  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10095  				return err
 10096  			}
 10097  			iNdEx = postIndex
 10098  		case 3:
 10099  			if wireType != 2 {
 10100  				return fmt.Errorf("proto: wrong wireType = %d for field FQDN", wireType)
 10101  			}
 10102  			var stringLen uint64
 10103  			for shift := uint(0); ; shift += 7 {
 10104  				if shift >= 64 {
 10105  					return ErrIntOverflow
 10106  				}
 10107  				if iNdEx >= l {
 10108  					return io.ErrUnexpectedEOF
 10109  				}
 10110  				b := dAtA[iNdEx]
 10111  				iNdEx++
 10112  				stringLen |= uint64(b&0x7F) << shift
 10113  				if b < 0x80 {
 10114  					break
 10115  				}
 10116  			}
 10117  			intStringLen := int(stringLen)
 10118  			if intStringLen < 0 {
 10119  				return ErrInvalidLength
 10120  			}
 10121  			postIndex := iNdEx + intStringLen
 10122  			if postIndex < 0 {
 10123  				return ErrInvalidLength
 10124  			}
 10125  			if postIndex > l {
 10126  				return io.ErrUnexpectedEOF
 10127  			}
 10128  			m.FQDN = string(dAtA[iNdEx:postIndex])
 10129  			iNdEx = postIndex
 10130  		default:
 10131  			iNdEx = preIndex
 10132  			skippy, err := skip(dAtA[iNdEx:])
 10133  			if err != nil {
 10134  				return err
 10135  			}
 10136  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10137  				return ErrInvalidLength
 10138  			}
 10139  			if (iNdEx + skippy) > l {
 10140  				return io.ErrUnexpectedEOF
 10141  			}
 10142  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10143  			iNdEx += skippy
 10144  		}
 10145  	}
 10146  
 10147  	if iNdEx > l {
 10148  		return io.ErrUnexpectedEOF
 10149  	}
 10150  	return nil
 10151  }
 10152  func (m *VTGate) UnmarshalVT(dAtA []byte) error {
 10153  	l := len(dAtA)
 10154  	iNdEx := 0
 10155  	for iNdEx < l {
 10156  		preIndex := iNdEx
 10157  		var wire uint64
 10158  		for shift := uint(0); ; shift += 7 {
 10159  			if shift >= 64 {
 10160  				return ErrIntOverflow
 10161  			}
 10162  			if iNdEx >= l {
 10163  				return io.ErrUnexpectedEOF
 10164  			}
 10165  			b := dAtA[iNdEx]
 10166  			iNdEx++
 10167  			wire |= uint64(b&0x7F) << shift
 10168  			if b < 0x80 {
 10169  				break
 10170  			}
 10171  		}
 10172  		fieldNum := int32(wire >> 3)
 10173  		wireType := int(wire & 0x7)
 10174  		if wireType == 4 {
 10175  			return fmt.Errorf("proto: VTGate: wiretype end group for non-group")
 10176  		}
 10177  		if fieldNum <= 0 {
 10178  			return fmt.Errorf("proto: VTGate: illegal tag %d (wire type %d)", fieldNum, wire)
 10179  		}
 10180  		switch fieldNum {
 10181  		case 1:
 10182  			if wireType != 2 {
 10183  				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
 10184  			}
 10185  			var stringLen uint64
 10186  			for shift := uint(0); ; shift += 7 {
 10187  				if shift >= 64 {
 10188  					return ErrIntOverflow
 10189  				}
 10190  				if iNdEx >= l {
 10191  					return io.ErrUnexpectedEOF
 10192  				}
 10193  				b := dAtA[iNdEx]
 10194  				iNdEx++
 10195  				stringLen |= uint64(b&0x7F) << shift
 10196  				if b < 0x80 {
 10197  					break
 10198  				}
 10199  			}
 10200  			intStringLen := int(stringLen)
 10201  			if intStringLen < 0 {
 10202  				return ErrInvalidLength
 10203  			}
 10204  			postIndex := iNdEx + intStringLen
 10205  			if postIndex < 0 {
 10206  				return ErrInvalidLength
 10207  			}
 10208  			if postIndex > l {
 10209  				return io.ErrUnexpectedEOF
 10210  			}
 10211  			m.Hostname = string(dAtA[iNdEx:postIndex])
 10212  			iNdEx = postIndex
 10213  		case 2:
 10214  			if wireType != 2 {
 10215  				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
 10216  			}
 10217  			var stringLen uint64
 10218  			for shift := uint(0); ; shift += 7 {
 10219  				if shift >= 64 {
 10220  					return ErrIntOverflow
 10221  				}
 10222  				if iNdEx >= l {
 10223  					return io.ErrUnexpectedEOF
 10224  				}
 10225  				b := dAtA[iNdEx]
 10226  				iNdEx++
 10227  				stringLen |= uint64(b&0x7F) << shift
 10228  				if b < 0x80 {
 10229  					break
 10230  				}
 10231  			}
 10232  			intStringLen := int(stringLen)
 10233  			if intStringLen < 0 {
 10234  				return ErrInvalidLength
 10235  			}
 10236  			postIndex := iNdEx + intStringLen
 10237  			if postIndex < 0 {
 10238  				return ErrInvalidLength
 10239  			}
 10240  			if postIndex > l {
 10241  				return io.ErrUnexpectedEOF
 10242  			}
 10243  			m.Pool = string(dAtA[iNdEx:postIndex])
 10244  			iNdEx = postIndex
 10245  		case 3:
 10246  			if wireType != 2 {
 10247  				return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType)
 10248  			}
 10249  			var stringLen uint64
 10250  			for shift := uint(0); ; shift += 7 {
 10251  				if shift >= 64 {
 10252  					return ErrIntOverflow
 10253  				}
 10254  				if iNdEx >= l {
 10255  					return io.ErrUnexpectedEOF
 10256  				}
 10257  				b := dAtA[iNdEx]
 10258  				iNdEx++
 10259  				stringLen |= uint64(b&0x7F) << shift
 10260  				if b < 0x80 {
 10261  					break
 10262  				}
 10263  			}
 10264  			intStringLen := int(stringLen)
 10265  			if intStringLen < 0 {
 10266  				return ErrInvalidLength
 10267  			}
 10268  			postIndex := iNdEx + intStringLen
 10269  			if postIndex < 0 {
 10270  				return ErrInvalidLength
 10271  			}
 10272  			if postIndex > l {
 10273  				return io.ErrUnexpectedEOF
 10274  			}
 10275  			m.Cell = string(dAtA[iNdEx:postIndex])
 10276  			iNdEx = postIndex
 10277  		case 4:
 10278  			if wireType != 2 {
 10279  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 10280  			}
 10281  			var msglen int
 10282  			for shift := uint(0); ; shift += 7 {
 10283  				if shift >= 64 {
 10284  					return ErrIntOverflow
 10285  				}
 10286  				if iNdEx >= l {
 10287  					return io.ErrUnexpectedEOF
 10288  				}
 10289  				b := dAtA[iNdEx]
 10290  				iNdEx++
 10291  				msglen |= int(b&0x7F) << shift
 10292  				if b < 0x80 {
 10293  					break
 10294  				}
 10295  			}
 10296  			if msglen < 0 {
 10297  				return ErrInvalidLength
 10298  			}
 10299  			postIndex := iNdEx + msglen
 10300  			if postIndex < 0 {
 10301  				return ErrInvalidLength
 10302  			}
 10303  			if postIndex > l {
 10304  				return io.ErrUnexpectedEOF
 10305  			}
 10306  			if m.Cluster == nil {
 10307  				m.Cluster = &Cluster{}
 10308  			}
 10309  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10310  				return err
 10311  			}
 10312  			iNdEx = postIndex
 10313  		case 5:
 10314  			if wireType != 2 {
 10315  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspaces", wireType)
 10316  			}
 10317  			var stringLen uint64
 10318  			for shift := uint(0); ; shift += 7 {
 10319  				if shift >= 64 {
 10320  					return ErrIntOverflow
 10321  				}
 10322  				if iNdEx >= l {
 10323  					return io.ErrUnexpectedEOF
 10324  				}
 10325  				b := dAtA[iNdEx]
 10326  				iNdEx++
 10327  				stringLen |= uint64(b&0x7F) << shift
 10328  				if b < 0x80 {
 10329  					break
 10330  				}
 10331  			}
 10332  			intStringLen := int(stringLen)
 10333  			if intStringLen < 0 {
 10334  				return ErrInvalidLength
 10335  			}
 10336  			postIndex := iNdEx + intStringLen
 10337  			if postIndex < 0 {
 10338  				return ErrInvalidLength
 10339  			}
 10340  			if postIndex > l {
 10341  				return io.ErrUnexpectedEOF
 10342  			}
 10343  			m.Keyspaces = append(m.Keyspaces, string(dAtA[iNdEx:postIndex]))
 10344  			iNdEx = postIndex
 10345  		case 6:
 10346  			if wireType != 2 {
 10347  				return fmt.Errorf("proto: wrong wireType = %d for field FQDN", wireType)
 10348  			}
 10349  			var stringLen uint64
 10350  			for shift := uint(0); ; shift += 7 {
 10351  				if shift >= 64 {
 10352  					return ErrIntOverflow
 10353  				}
 10354  				if iNdEx >= l {
 10355  					return io.ErrUnexpectedEOF
 10356  				}
 10357  				b := dAtA[iNdEx]
 10358  				iNdEx++
 10359  				stringLen |= uint64(b&0x7F) << shift
 10360  				if b < 0x80 {
 10361  					break
 10362  				}
 10363  			}
 10364  			intStringLen := int(stringLen)
 10365  			if intStringLen < 0 {
 10366  				return ErrInvalidLength
 10367  			}
 10368  			postIndex := iNdEx + intStringLen
 10369  			if postIndex < 0 {
 10370  				return ErrInvalidLength
 10371  			}
 10372  			if postIndex > l {
 10373  				return io.ErrUnexpectedEOF
 10374  			}
 10375  			m.FQDN = string(dAtA[iNdEx:postIndex])
 10376  			iNdEx = postIndex
 10377  		default:
 10378  			iNdEx = preIndex
 10379  			skippy, err := skip(dAtA[iNdEx:])
 10380  			if err != nil {
 10381  				return err
 10382  			}
 10383  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10384  				return ErrInvalidLength
 10385  			}
 10386  			if (iNdEx + skippy) > l {
 10387  				return io.ErrUnexpectedEOF
 10388  			}
 10389  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10390  			iNdEx += skippy
 10391  		}
 10392  	}
 10393  
 10394  	if iNdEx > l {
 10395  		return io.ErrUnexpectedEOF
 10396  	}
 10397  	return nil
 10398  }
 10399  func (m *Workflow) UnmarshalVT(dAtA []byte) error {
 10400  	l := len(dAtA)
 10401  	iNdEx := 0
 10402  	for iNdEx < l {
 10403  		preIndex := iNdEx
 10404  		var wire uint64
 10405  		for shift := uint(0); ; shift += 7 {
 10406  			if shift >= 64 {
 10407  				return ErrIntOverflow
 10408  			}
 10409  			if iNdEx >= l {
 10410  				return io.ErrUnexpectedEOF
 10411  			}
 10412  			b := dAtA[iNdEx]
 10413  			iNdEx++
 10414  			wire |= uint64(b&0x7F) << shift
 10415  			if b < 0x80 {
 10416  				break
 10417  			}
 10418  		}
 10419  		fieldNum := int32(wire >> 3)
 10420  		wireType := int(wire & 0x7)
 10421  		if wireType == 4 {
 10422  			return fmt.Errorf("proto: Workflow: wiretype end group for non-group")
 10423  		}
 10424  		if fieldNum <= 0 {
 10425  			return fmt.Errorf("proto: Workflow: illegal tag %d (wire type %d)", fieldNum, wire)
 10426  		}
 10427  		switch fieldNum {
 10428  		case 1:
 10429  			if wireType != 2 {
 10430  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 10431  			}
 10432  			var msglen int
 10433  			for shift := uint(0); ; shift += 7 {
 10434  				if shift >= 64 {
 10435  					return ErrIntOverflow
 10436  				}
 10437  				if iNdEx >= l {
 10438  					return io.ErrUnexpectedEOF
 10439  				}
 10440  				b := dAtA[iNdEx]
 10441  				iNdEx++
 10442  				msglen |= int(b&0x7F) << shift
 10443  				if b < 0x80 {
 10444  					break
 10445  				}
 10446  			}
 10447  			if msglen < 0 {
 10448  				return ErrInvalidLength
 10449  			}
 10450  			postIndex := iNdEx + msglen
 10451  			if postIndex < 0 {
 10452  				return ErrInvalidLength
 10453  			}
 10454  			if postIndex > l {
 10455  				return io.ErrUnexpectedEOF
 10456  			}
 10457  			if m.Cluster == nil {
 10458  				m.Cluster = &Cluster{}
 10459  			}
 10460  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10461  				return err
 10462  			}
 10463  			iNdEx = postIndex
 10464  		case 2:
 10465  			if wireType != 2 {
 10466  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 10467  			}
 10468  			var stringLen uint64
 10469  			for shift := uint(0); ; shift += 7 {
 10470  				if shift >= 64 {
 10471  					return ErrIntOverflow
 10472  				}
 10473  				if iNdEx >= l {
 10474  					return io.ErrUnexpectedEOF
 10475  				}
 10476  				b := dAtA[iNdEx]
 10477  				iNdEx++
 10478  				stringLen |= uint64(b&0x7F) << shift
 10479  				if b < 0x80 {
 10480  					break
 10481  				}
 10482  			}
 10483  			intStringLen := int(stringLen)
 10484  			if intStringLen < 0 {
 10485  				return ErrInvalidLength
 10486  			}
 10487  			postIndex := iNdEx + intStringLen
 10488  			if postIndex < 0 {
 10489  				return ErrInvalidLength
 10490  			}
 10491  			if postIndex > l {
 10492  				return io.ErrUnexpectedEOF
 10493  			}
 10494  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 10495  			iNdEx = postIndex
 10496  		case 3:
 10497  			if wireType != 2 {
 10498  				return fmt.Errorf("proto: wrong wireType = %d for field Workflow", wireType)
 10499  			}
 10500  			var msglen int
 10501  			for shift := uint(0); ; shift += 7 {
 10502  				if shift >= 64 {
 10503  					return ErrIntOverflow
 10504  				}
 10505  				if iNdEx >= l {
 10506  					return io.ErrUnexpectedEOF
 10507  				}
 10508  				b := dAtA[iNdEx]
 10509  				iNdEx++
 10510  				msglen |= int(b&0x7F) << shift
 10511  				if b < 0x80 {
 10512  					break
 10513  				}
 10514  			}
 10515  			if msglen < 0 {
 10516  				return ErrInvalidLength
 10517  			}
 10518  			postIndex := iNdEx + msglen
 10519  			if postIndex < 0 {
 10520  				return ErrInvalidLength
 10521  			}
 10522  			if postIndex > l {
 10523  				return io.ErrUnexpectedEOF
 10524  			}
 10525  			if m.Workflow == nil {
 10526  				m.Workflow = &vtctldata.Workflow{}
 10527  			}
 10528  			if err := m.Workflow.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10529  				return err
 10530  			}
 10531  			iNdEx = postIndex
 10532  		default:
 10533  			iNdEx = preIndex
 10534  			skippy, err := skip(dAtA[iNdEx:])
 10535  			if err != nil {
 10536  				return err
 10537  			}
 10538  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10539  				return ErrInvalidLength
 10540  			}
 10541  			if (iNdEx + skippy) > l {
 10542  				return io.ErrUnexpectedEOF
 10543  			}
 10544  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10545  			iNdEx += skippy
 10546  		}
 10547  	}
 10548  
 10549  	if iNdEx > l {
 10550  		return io.ErrUnexpectedEOF
 10551  	}
 10552  	return nil
 10553  }
 10554  func (m *CreateKeyspaceRequest) UnmarshalVT(dAtA []byte) error {
 10555  	l := len(dAtA)
 10556  	iNdEx := 0
 10557  	for iNdEx < l {
 10558  		preIndex := iNdEx
 10559  		var wire uint64
 10560  		for shift := uint(0); ; shift += 7 {
 10561  			if shift >= 64 {
 10562  				return ErrIntOverflow
 10563  			}
 10564  			if iNdEx >= l {
 10565  				return io.ErrUnexpectedEOF
 10566  			}
 10567  			b := dAtA[iNdEx]
 10568  			iNdEx++
 10569  			wire |= uint64(b&0x7F) << shift
 10570  			if b < 0x80 {
 10571  				break
 10572  			}
 10573  		}
 10574  		fieldNum := int32(wire >> 3)
 10575  		wireType := int(wire & 0x7)
 10576  		if wireType == 4 {
 10577  			return fmt.Errorf("proto: CreateKeyspaceRequest: wiretype end group for non-group")
 10578  		}
 10579  		if fieldNum <= 0 {
 10580  			return fmt.Errorf("proto: CreateKeyspaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10581  		}
 10582  		switch fieldNum {
 10583  		case 1:
 10584  			if wireType != 2 {
 10585  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 10586  			}
 10587  			var stringLen uint64
 10588  			for shift := uint(0); ; shift += 7 {
 10589  				if shift >= 64 {
 10590  					return ErrIntOverflow
 10591  				}
 10592  				if iNdEx >= l {
 10593  					return io.ErrUnexpectedEOF
 10594  				}
 10595  				b := dAtA[iNdEx]
 10596  				iNdEx++
 10597  				stringLen |= uint64(b&0x7F) << shift
 10598  				if b < 0x80 {
 10599  					break
 10600  				}
 10601  			}
 10602  			intStringLen := int(stringLen)
 10603  			if intStringLen < 0 {
 10604  				return ErrInvalidLength
 10605  			}
 10606  			postIndex := iNdEx + intStringLen
 10607  			if postIndex < 0 {
 10608  				return ErrInvalidLength
 10609  			}
 10610  			if postIndex > l {
 10611  				return io.ErrUnexpectedEOF
 10612  			}
 10613  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 10614  			iNdEx = postIndex
 10615  		case 2:
 10616  			if wireType != 2 {
 10617  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 10618  			}
 10619  			var msglen int
 10620  			for shift := uint(0); ; shift += 7 {
 10621  				if shift >= 64 {
 10622  					return ErrIntOverflow
 10623  				}
 10624  				if iNdEx >= l {
 10625  					return io.ErrUnexpectedEOF
 10626  				}
 10627  				b := dAtA[iNdEx]
 10628  				iNdEx++
 10629  				msglen |= int(b&0x7F) << shift
 10630  				if b < 0x80 {
 10631  					break
 10632  				}
 10633  			}
 10634  			if msglen < 0 {
 10635  				return ErrInvalidLength
 10636  			}
 10637  			postIndex := iNdEx + msglen
 10638  			if postIndex < 0 {
 10639  				return ErrInvalidLength
 10640  			}
 10641  			if postIndex > l {
 10642  				return io.ErrUnexpectedEOF
 10643  			}
 10644  			if m.Options == nil {
 10645  				m.Options = &vtctldata.CreateKeyspaceRequest{}
 10646  			}
 10647  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10648  				return err
 10649  			}
 10650  			iNdEx = postIndex
 10651  		default:
 10652  			iNdEx = preIndex
 10653  			skippy, err := skip(dAtA[iNdEx:])
 10654  			if err != nil {
 10655  				return err
 10656  			}
 10657  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10658  				return ErrInvalidLength
 10659  			}
 10660  			if (iNdEx + skippy) > l {
 10661  				return io.ErrUnexpectedEOF
 10662  			}
 10663  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10664  			iNdEx += skippy
 10665  		}
 10666  	}
 10667  
 10668  	if iNdEx > l {
 10669  		return io.ErrUnexpectedEOF
 10670  	}
 10671  	return nil
 10672  }
 10673  func (m *CreateKeyspaceResponse) UnmarshalVT(dAtA []byte) error {
 10674  	l := len(dAtA)
 10675  	iNdEx := 0
 10676  	for iNdEx < l {
 10677  		preIndex := iNdEx
 10678  		var wire uint64
 10679  		for shift := uint(0); ; shift += 7 {
 10680  			if shift >= 64 {
 10681  				return ErrIntOverflow
 10682  			}
 10683  			if iNdEx >= l {
 10684  				return io.ErrUnexpectedEOF
 10685  			}
 10686  			b := dAtA[iNdEx]
 10687  			iNdEx++
 10688  			wire |= uint64(b&0x7F) << shift
 10689  			if b < 0x80 {
 10690  				break
 10691  			}
 10692  		}
 10693  		fieldNum := int32(wire >> 3)
 10694  		wireType := int(wire & 0x7)
 10695  		if wireType == 4 {
 10696  			return fmt.Errorf("proto: CreateKeyspaceResponse: wiretype end group for non-group")
 10697  		}
 10698  		if fieldNum <= 0 {
 10699  			return fmt.Errorf("proto: CreateKeyspaceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10700  		}
 10701  		switch fieldNum {
 10702  		case 1:
 10703  			if wireType != 2 {
 10704  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 10705  			}
 10706  			var msglen int
 10707  			for shift := uint(0); ; shift += 7 {
 10708  				if shift >= 64 {
 10709  					return ErrIntOverflow
 10710  				}
 10711  				if iNdEx >= l {
 10712  					return io.ErrUnexpectedEOF
 10713  				}
 10714  				b := dAtA[iNdEx]
 10715  				iNdEx++
 10716  				msglen |= int(b&0x7F) << shift
 10717  				if b < 0x80 {
 10718  					break
 10719  				}
 10720  			}
 10721  			if msglen < 0 {
 10722  				return ErrInvalidLength
 10723  			}
 10724  			postIndex := iNdEx + msglen
 10725  			if postIndex < 0 {
 10726  				return ErrInvalidLength
 10727  			}
 10728  			if postIndex > l {
 10729  				return io.ErrUnexpectedEOF
 10730  			}
 10731  			if m.Keyspace == nil {
 10732  				m.Keyspace = &Keyspace{}
 10733  			}
 10734  			if err := m.Keyspace.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10735  				return err
 10736  			}
 10737  			iNdEx = postIndex
 10738  		default:
 10739  			iNdEx = preIndex
 10740  			skippy, err := skip(dAtA[iNdEx:])
 10741  			if err != nil {
 10742  				return err
 10743  			}
 10744  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10745  				return ErrInvalidLength
 10746  			}
 10747  			if (iNdEx + skippy) > l {
 10748  				return io.ErrUnexpectedEOF
 10749  			}
 10750  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10751  			iNdEx += skippy
 10752  		}
 10753  	}
 10754  
 10755  	if iNdEx > l {
 10756  		return io.ErrUnexpectedEOF
 10757  	}
 10758  	return nil
 10759  }
 10760  func (m *CreateShardRequest) UnmarshalVT(dAtA []byte) error {
 10761  	l := len(dAtA)
 10762  	iNdEx := 0
 10763  	for iNdEx < l {
 10764  		preIndex := iNdEx
 10765  		var wire uint64
 10766  		for shift := uint(0); ; shift += 7 {
 10767  			if shift >= 64 {
 10768  				return ErrIntOverflow
 10769  			}
 10770  			if iNdEx >= l {
 10771  				return io.ErrUnexpectedEOF
 10772  			}
 10773  			b := dAtA[iNdEx]
 10774  			iNdEx++
 10775  			wire |= uint64(b&0x7F) << shift
 10776  			if b < 0x80 {
 10777  				break
 10778  			}
 10779  		}
 10780  		fieldNum := int32(wire >> 3)
 10781  		wireType := int(wire & 0x7)
 10782  		if wireType == 4 {
 10783  			return fmt.Errorf("proto: CreateShardRequest: wiretype end group for non-group")
 10784  		}
 10785  		if fieldNum <= 0 {
 10786  			return fmt.Errorf("proto: CreateShardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10787  		}
 10788  		switch fieldNum {
 10789  		case 1:
 10790  			if wireType != 2 {
 10791  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 10792  			}
 10793  			var stringLen uint64
 10794  			for shift := uint(0); ; shift += 7 {
 10795  				if shift >= 64 {
 10796  					return ErrIntOverflow
 10797  				}
 10798  				if iNdEx >= l {
 10799  					return io.ErrUnexpectedEOF
 10800  				}
 10801  				b := dAtA[iNdEx]
 10802  				iNdEx++
 10803  				stringLen |= uint64(b&0x7F) << shift
 10804  				if b < 0x80 {
 10805  					break
 10806  				}
 10807  			}
 10808  			intStringLen := int(stringLen)
 10809  			if intStringLen < 0 {
 10810  				return ErrInvalidLength
 10811  			}
 10812  			postIndex := iNdEx + intStringLen
 10813  			if postIndex < 0 {
 10814  				return ErrInvalidLength
 10815  			}
 10816  			if postIndex > l {
 10817  				return io.ErrUnexpectedEOF
 10818  			}
 10819  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 10820  			iNdEx = postIndex
 10821  		case 2:
 10822  			if wireType != 2 {
 10823  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 10824  			}
 10825  			var msglen int
 10826  			for shift := uint(0); ; shift += 7 {
 10827  				if shift >= 64 {
 10828  					return ErrIntOverflow
 10829  				}
 10830  				if iNdEx >= l {
 10831  					return io.ErrUnexpectedEOF
 10832  				}
 10833  				b := dAtA[iNdEx]
 10834  				iNdEx++
 10835  				msglen |= int(b&0x7F) << shift
 10836  				if b < 0x80 {
 10837  					break
 10838  				}
 10839  			}
 10840  			if msglen < 0 {
 10841  				return ErrInvalidLength
 10842  			}
 10843  			postIndex := iNdEx + msglen
 10844  			if postIndex < 0 {
 10845  				return ErrInvalidLength
 10846  			}
 10847  			if postIndex > l {
 10848  				return io.ErrUnexpectedEOF
 10849  			}
 10850  			if m.Options == nil {
 10851  				m.Options = &vtctldata.CreateShardRequest{}
 10852  			}
 10853  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10854  				return err
 10855  			}
 10856  			iNdEx = postIndex
 10857  		default:
 10858  			iNdEx = preIndex
 10859  			skippy, err := skip(dAtA[iNdEx:])
 10860  			if err != nil {
 10861  				return err
 10862  			}
 10863  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10864  				return ErrInvalidLength
 10865  			}
 10866  			if (iNdEx + skippy) > l {
 10867  				return io.ErrUnexpectedEOF
 10868  			}
 10869  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10870  			iNdEx += skippy
 10871  		}
 10872  	}
 10873  
 10874  	if iNdEx > l {
 10875  		return io.ErrUnexpectedEOF
 10876  	}
 10877  	return nil
 10878  }
 10879  func (m *DeleteKeyspaceRequest) UnmarshalVT(dAtA []byte) error {
 10880  	l := len(dAtA)
 10881  	iNdEx := 0
 10882  	for iNdEx < l {
 10883  		preIndex := iNdEx
 10884  		var wire uint64
 10885  		for shift := uint(0); ; shift += 7 {
 10886  			if shift >= 64 {
 10887  				return ErrIntOverflow
 10888  			}
 10889  			if iNdEx >= l {
 10890  				return io.ErrUnexpectedEOF
 10891  			}
 10892  			b := dAtA[iNdEx]
 10893  			iNdEx++
 10894  			wire |= uint64(b&0x7F) << shift
 10895  			if b < 0x80 {
 10896  				break
 10897  			}
 10898  		}
 10899  		fieldNum := int32(wire >> 3)
 10900  		wireType := int(wire & 0x7)
 10901  		if wireType == 4 {
 10902  			return fmt.Errorf("proto: DeleteKeyspaceRequest: wiretype end group for non-group")
 10903  		}
 10904  		if fieldNum <= 0 {
 10905  			return fmt.Errorf("proto: DeleteKeyspaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10906  		}
 10907  		switch fieldNum {
 10908  		case 1:
 10909  			if wireType != 2 {
 10910  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 10911  			}
 10912  			var stringLen uint64
 10913  			for shift := uint(0); ; shift += 7 {
 10914  				if shift >= 64 {
 10915  					return ErrIntOverflow
 10916  				}
 10917  				if iNdEx >= l {
 10918  					return io.ErrUnexpectedEOF
 10919  				}
 10920  				b := dAtA[iNdEx]
 10921  				iNdEx++
 10922  				stringLen |= uint64(b&0x7F) << shift
 10923  				if b < 0x80 {
 10924  					break
 10925  				}
 10926  			}
 10927  			intStringLen := int(stringLen)
 10928  			if intStringLen < 0 {
 10929  				return ErrInvalidLength
 10930  			}
 10931  			postIndex := iNdEx + intStringLen
 10932  			if postIndex < 0 {
 10933  				return ErrInvalidLength
 10934  			}
 10935  			if postIndex > l {
 10936  				return io.ErrUnexpectedEOF
 10937  			}
 10938  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 10939  			iNdEx = postIndex
 10940  		case 2:
 10941  			if wireType != 2 {
 10942  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 10943  			}
 10944  			var msglen int
 10945  			for shift := uint(0); ; shift += 7 {
 10946  				if shift >= 64 {
 10947  					return ErrIntOverflow
 10948  				}
 10949  				if iNdEx >= l {
 10950  					return io.ErrUnexpectedEOF
 10951  				}
 10952  				b := dAtA[iNdEx]
 10953  				iNdEx++
 10954  				msglen |= int(b&0x7F) << shift
 10955  				if b < 0x80 {
 10956  					break
 10957  				}
 10958  			}
 10959  			if msglen < 0 {
 10960  				return ErrInvalidLength
 10961  			}
 10962  			postIndex := iNdEx + msglen
 10963  			if postIndex < 0 {
 10964  				return ErrInvalidLength
 10965  			}
 10966  			if postIndex > l {
 10967  				return io.ErrUnexpectedEOF
 10968  			}
 10969  			if m.Options == nil {
 10970  				m.Options = &vtctldata.DeleteKeyspaceRequest{}
 10971  			}
 10972  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10973  				return err
 10974  			}
 10975  			iNdEx = postIndex
 10976  		default:
 10977  			iNdEx = preIndex
 10978  			skippy, err := skip(dAtA[iNdEx:])
 10979  			if err != nil {
 10980  				return err
 10981  			}
 10982  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10983  				return ErrInvalidLength
 10984  			}
 10985  			if (iNdEx + skippy) > l {
 10986  				return io.ErrUnexpectedEOF
 10987  			}
 10988  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10989  			iNdEx += skippy
 10990  		}
 10991  	}
 10992  
 10993  	if iNdEx > l {
 10994  		return io.ErrUnexpectedEOF
 10995  	}
 10996  	return nil
 10997  }
 10998  func (m *DeleteShardsRequest) UnmarshalVT(dAtA []byte) error {
 10999  	l := len(dAtA)
 11000  	iNdEx := 0
 11001  	for iNdEx < l {
 11002  		preIndex := iNdEx
 11003  		var wire uint64
 11004  		for shift := uint(0); ; shift += 7 {
 11005  			if shift >= 64 {
 11006  				return ErrIntOverflow
 11007  			}
 11008  			if iNdEx >= l {
 11009  				return io.ErrUnexpectedEOF
 11010  			}
 11011  			b := dAtA[iNdEx]
 11012  			iNdEx++
 11013  			wire |= uint64(b&0x7F) << shift
 11014  			if b < 0x80 {
 11015  				break
 11016  			}
 11017  		}
 11018  		fieldNum := int32(wire >> 3)
 11019  		wireType := int(wire & 0x7)
 11020  		if wireType == 4 {
 11021  			return fmt.Errorf("proto: DeleteShardsRequest: wiretype end group for non-group")
 11022  		}
 11023  		if fieldNum <= 0 {
 11024  			return fmt.Errorf("proto: DeleteShardsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11025  		}
 11026  		switch fieldNum {
 11027  		case 1:
 11028  			if wireType != 2 {
 11029  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 11030  			}
 11031  			var stringLen uint64
 11032  			for shift := uint(0); ; shift += 7 {
 11033  				if shift >= 64 {
 11034  					return ErrIntOverflow
 11035  				}
 11036  				if iNdEx >= l {
 11037  					return io.ErrUnexpectedEOF
 11038  				}
 11039  				b := dAtA[iNdEx]
 11040  				iNdEx++
 11041  				stringLen |= uint64(b&0x7F) << shift
 11042  				if b < 0x80 {
 11043  					break
 11044  				}
 11045  			}
 11046  			intStringLen := int(stringLen)
 11047  			if intStringLen < 0 {
 11048  				return ErrInvalidLength
 11049  			}
 11050  			postIndex := iNdEx + intStringLen
 11051  			if postIndex < 0 {
 11052  				return ErrInvalidLength
 11053  			}
 11054  			if postIndex > l {
 11055  				return io.ErrUnexpectedEOF
 11056  			}
 11057  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 11058  			iNdEx = postIndex
 11059  		case 2:
 11060  			if wireType != 2 {
 11061  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 11062  			}
 11063  			var msglen int
 11064  			for shift := uint(0); ; shift += 7 {
 11065  				if shift >= 64 {
 11066  					return ErrIntOverflow
 11067  				}
 11068  				if iNdEx >= l {
 11069  					return io.ErrUnexpectedEOF
 11070  				}
 11071  				b := dAtA[iNdEx]
 11072  				iNdEx++
 11073  				msglen |= int(b&0x7F) << shift
 11074  				if b < 0x80 {
 11075  					break
 11076  				}
 11077  			}
 11078  			if msglen < 0 {
 11079  				return ErrInvalidLength
 11080  			}
 11081  			postIndex := iNdEx + msglen
 11082  			if postIndex < 0 {
 11083  				return ErrInvalidLength
 11084  			}
 11085  			if postIndex > l {
 11086  				return io.ErrUnexpectedEOF
 11087  			}
 11088  			if m.Options == nil {
 11089  				m.Options = &vtctldata.DeleteShardsRequest{}
 11090  			}
 11091  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11092  				return err
 11093  			}
 11094  			iNdEx = postIndex
 11095  		default:
 11096  			iNdEx = preIndex
 11097  			skippy, err := skip(dAtA[iNdEx:])
 11098  			if err != nil {
 11099  				return err
 11100  			}
 11101  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11102  				return ErrInvalidLength
 11103  			}
 11104  			if (iNdEx + skippy) > l {
 11105  				return io.ErrUnexpectedEOF
 11106  			}
 11107  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11108  			iNdEx += skippy
 11109  		}
 11110  	}
 11111  
 11112  	if iNdEx > l {
 11113  		return io.ErrUnexpectedEOF
 11114  	}
 11115  	return nil
 11116  }
 11117  func (m *DeleteTabletRequest) UnmarshalVT(dAtA []byte) error {
 11118  	l := len(dAtA)
 11119  	iNdEx := 0
 11120  	for iNdEx < l {
 11121  		preIndex := iNdEx
 11122  		var wire uint64
 11123  		for shift := uint(0); ; shift += 7 {
 11124  			if shift >= 64 {
 11125  				return ErrIntOverflow
 11126  			}
 11127  			if iNdEx >= l {
 11128  				return io.ErrUnexpectedEOF
 11129  			}
 11130  			b := dAtA[iNdEx]
 11131  			iNdEx++
 11132  			wire |= uint64(b&0x7F) << shift
 11133  			if b < 0x80 {
 11134  				break
 11135  			}
 11136  		}
 11137  		fieldNum := int32(wire >> 3)
 11138  		wireType := int(wire & 0x7)
 11139  		if wireType == 4 {
 11140  			return fmt.Errorf("proto: DeleteTabletRequest: wiretype end group for non-group")
 11141  		}
 11142  		if fieldNum <= 0 {
 11143  			return fmt.Errorf("proto: DeleteTabletRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11144  		}
 11145  		switch fieldNum {
 11146  		case 1:
 11147  			if wireType != 2 {
 11148  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 11149  			}
 11150  			var msglen int
 11151  			for shift := uint(0); ; shift += 7 {
 11152  				if shift >= 64 {
 11153  					return ErrIntOverflow
 11154  				}
 11155  				if iNdEx >= l {
 11156  					return io.ErrUnexpectedEOF
 11157  				}
 11158  				b := dAtA[iNdEx]
 11159  				iNdEx++
 11160  				msglen |= int(b&0x7F) << shift
 11161  				if b < 0x80 {
 11162  					break
 11163  				}
 11164  			}
 11165  			if msglen < 0 {
 11166  				return ErrInvalidLength
 11167  			}
 11168  			postIndex := iNdEx + msglen
 11169  			if postIndex < 0 {
 11170  				return ErrInvalidLength
 11171  			}
 11172  			if postIndex > l {
 11173  				return io.ErrUnexpectedEOF
 11174  			}
 11175  			if m.Alias == nil {
 11176  				m.Alias = &topodata.TabletAlias{}
 11177  			}
 11178  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11179  				return err
 11180  			}
 11181  			iNdEx = postIndex
 11182  		case 2:
 11183  			if wireType != 2 {
 11184  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 11185  			}
 11186  			var stringLen uint64
 11187  			for shift := uint(0); ; shift += 7 {
 11188  				if shift >= 64 {
 11189  					return ErrIntOverflow
 11190  				}
 11191  				if iNdEx >= l {
 11192  					return io.ErrUnexpectedEOF
 11193  				}
 11194  				b := dAtA[iNdEx]
 11195  				iNdEx++
 11196  				stringLen |= uint64(b&0x7F) << shift
 11197  				if b < 0x80 {
 11198  					break
 11199  				}
 11200  			}
 11201  			intStringLen := int(stringLen)
 11202  			if intStringLen < 0 {
 11203  				return ErrInvalidLength
 11204  			}
 11205  			postIndex := iNdEx + intStringLen
 11206  			if postIndex < 0 {
 11207  				return ErrInvalidLength
 11208  			}
 11209  			if postIndex > l {
 11210  				return io.ErrUnexpectedEOF
 11211  			}
 11212  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 11213  			iNdEx = postIndex
 11214  		case 3:
 11215  			if wireType != 0 {
 11216  				return fmt.Errorf("proto: wrong wireType = %d for field AllowPrimary", wireType)
 11217  			}
 11218  			var v int
 11219  			for shift := uint(0); ; shift += 7 {
 11220  				if shift >= 64 {
 11221  					return ErrIntOverflow
 11222  				}
 11223  				if iNdEx >= l {
 11224  					return io.ErrUnexpectedEOF
 11225  				}
 11226  				b := dAtA[iNdEx]
 11227  				iNdEx++
 11228  				v |= int(b&0x7F) << shift
 11229  				if b < 0x80 {
 11230  					break
 11231  				}
 11232  			}
 11233  			m.AllowPrimary = bool(v != 0)
 11234  		default:
 11235  			iNdEx = preIndex
 11236  			skippy, err := skip(dAtA[iNdEx:])
 11237  			if err != nil {
 11238  				return err
 11239  			}
 11240  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11241  				return ErrInvalidLength
 11242  			}
 11243  			if (iNdEx + skippy) > l {
 11244  				return io.ErrUnexpectedEOF
 11245  			}
 11246  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11247  			iNdEx += skippy
 11248  		}
 11249  	}
 11250  
 11251  	if iNdEx > l {
 11252  		return io.ErrUnexpectedEOF
 11253  	}
 11254  	return nil
 11255  }
 11256  func (m *DeleteTabletResponse) UnmarshalVT(dAtA []byte) error {
 11257  	l := len(dAtA)
 11258  	iNdEx := 0
 11259  	for iNdEx < l {
 11260  		preIndex := iNdEx
 11261  		var wire uint64
 11262  		for shift := uint(0); ; shift += 7 {
 11263  			if shift >= 64 {
 11264  				return ErrIntOverflow
 11265  			}
 11266  			if iNdEx >= l {
 11267  				return io.ErrUnexpectedEOF
 11268  			}
 11269  			b := dAtA[iNdEx]
 11270  			iNdEx++
 11271  			wire |= uint64(b&0x7F) << shift
 11272  			if b < 0x80 {
 11273  				break
 11274  			}
 11275  		}
 11276  		fieldNum := int32(wire >> 3)
 11277  		wireType := int(wire & 0x7)
 11278  		if wireType == 4 {
 11279  			return fmt.Errorf("proto: DeleteTabletResponse: wiretype end group for non-group")
 11280  		}
 11281  		if fieldNum <= 0 {
 11282  			return fmt.Errorf("proto: DeleteTabletResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11283  		}
 11284  		switch fieldNum {
 11285  		case 1:
 11286  			if wireType != 2 {
 11287  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 11288  			}
 11289  			var stringLen uint64
 11290  			for shift := uint(0); ; shift += 7 {
 11291  				if shift >= 64 {
 11292  					return ErrIntOverflow
 11293  				}
 11294  				if iNdEx >= l {
 11295  					return io.ErrUnexpectedEOF
 11296  				}
 11297  				b := dAtA[iNdEx]
 11298  				iNdEx++
 11299  				stringLen |= uint64(b&0x7F) << shift
 11300  				if b < 0x80 {
 11301  					break
 11302  				}
 11303  			}
 11304  			intStringLen := int(stringLen)
 11305  			if intStringLen < 0 {
 11306  				return ErrInvalidLength
 11307  			}
 11308  			postIndex := iNdEx + intStringLen
 11309  			if postIndex < 0 {
 11310  				return ErrInvalidLength
 11311  			}
 11312  			if postIndex > l {
 11313  				return io.ErrUnexpectedEOF
 11314  			}
 11315  			m.Status = string(dAtA[iNdEx:postIndex])
 11316  			iNdEx = postIndex
 11317  		case 2:
 11318  			if wireType != 2 {
 11319  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 11320  			}
 11321  			var msglen int
 11322  			for shift := uint(0); ; shift += 7 {
 11323  				if shift >= 64 {
 11324  					return ErrIntOverflow
 11325  				}
 11326  				if iNdEx >= l {
 11327  					return io.ErrUnexpectedEOF
 11328  				}
 11329  				b := dAtA[iNdEx]
 11330  				iNdEx++
 11331  				msglen |= int(b&0x7F) << shift
 11332  				if b < 0x80 {
 11333  					break
 11334  				}
 11335  			}
 11336  			if msglen < 0 {
 11337  				return ErrInvalidLength
 11338  			}
 11339  			postIndex := iNdEx + msglen
 11340  			if postIndex < 0 {
 11341  				return ErrInvalidLength
 11342  			}
 11343  			if postIndex > l {
 11344  				return io.ErrUnexpectedEOF
 11345  			}
 11346  			if m.Cluster == nil {
 11347  				m.Cluster = &Cluster{}
 11348  			}
 11349  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11350  				return err
 11351  			}
 11352  			iNdEx = postIndex
 11353  		default:
 11354  			iNdEx = preIndex
 11355  			skippy, err := skip(dAtA[iNdEx:])
 11356  			if err != nil {
 11357  				return err
 11358  			}
 11359  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11360  				return ErrInvalidLength
 11361  			}
 11362  			if (iNdEx + skippy) > l {
 11363  				return io.ErrUnexpectedEOF
 11364  			}
 11365  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11366  			iNdEx += skippy
 11367  		}
 11368  	}
 11369  
 11370  	if iNdEx > l {
 11371  		return io.ErrUnexpectedEOF
 11372  	}
 11373  	return nil
 11374  }
 11375  func (m *EmergencyFailoverShardRequest) UnmarshalVT(dAtA []byte) error {
 11376  	l := len(dAtA)
 11377  	iNdEx := 0
 11378  	for iNdEx < l {
 11379  		preIndex := iNdEx
 11380  		var wire uint64
 11381  		for shift := uint(0); ; shift += 7 {
 11382  			if shift >= 64 {
 11383  				return ErrIntOverflow
 11384  			}
 11385  			if iNdEx >= l {
 11386  				return io.ErrUnexpectedEOF
 11387  			}
 11388  			b := dAtA[iNdEx]
 11389  			iNdEx++
 11390  			wire |= uint64(b&0x7F) << shift
 11391  			if b < 0x80 {
 11392  				break
 11393  			}
 11394  		}
 11395  		fieldNum := int32(wire >> 3)
 11396  		wireType := int(wire & 0x7)
 11397  		if wireType == 4 {
 11398  			return fmt.Errorf("proto: EmergencyFailoverShardRequest: wiretype end group for non-group")
 11399  		}
 11400  		if fieldNum <= 0 {
 11401  			return fmt.Errorf("proto: EmergencyFailoverShardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11402  		}
 11403  		switch fieldNum {
 11404  		case 1:
 11405  			if wireType != 2 {
 11406  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 11407  			}
 11408  			var stringLen uint64
 11409  			for shift := uint(0); ; shift += 7 {
 11410  				if shift >= 64 {
 11411  					return ErrIntOverflow
 11412  				}
 11413  				if iNdEx >= l {
 11414  					return io.ErrUnexpectedEOF
 11415  				}
 11416  				b := dAtA[iNdEx]
 11417  				iNdEx++
 11418  				stringLen |= uint64(b&0x7F) << shift
 11419  				if b < 0x80 {
 11420  					break
 11421  				}
 11422  			}
 11423  			intStringLen := int(stringLen)
 11424  			if intStringLen < 0 {
 11425  				return ErrInvalidLength
 11426  			}
 11427  			postIndex := iNdEx + intStringLen
 11428  			if postIndex < 0 {
 11429  				return ErrInvalidLength
 11430  			}
 11431  			if postIndex > l {
 11432  				return io.ErrUnexpectedEOF
 11433  			}
 11434  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 11435  			iNdEx = postIndex
 11436  		case 2:
 11437  			if wireType != 2 {
 11438  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 11439  			}
 11440  			var msglen int
 11441  			for shift := uint(0); ; shift += 7 {
 11442  				if shift >= 64 {
 11443  					return ErrIntOverflow
 11444  				}
 11445  				if iNdEx >= l {
 11446  					return io.ErrUnexpectedEOF
 11447  				}
 11448  				b := dAtA[iNdEx]
 11449  				iNdEx++
 11450  				msglen |= int(b&0x7F) << shift
 11451  				if b < 0x80 {
 11452  					break
 11453  				}
 11454  			}
 11455  			if msglen < 0 {
 11456  				return ErrInvalidLength
 11457  			}
 11458  			postIndex := iNdEx + msglen
 11459  			if postIndex < 0 {
 11460  				return ErrInvalidLength
 11461  			}
 11462  			if postIndex > l {
 11463  				return io.ErrUnexpectedEOF
 11464  			}
 11465  			if m.Options == nil {
 11466  				m.Options = &vtctldata.EmergencyReparentShardRequest{}
 11467  			}
 11468  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11469  				return err
 11470  			}
 11471  			iNdEx = postIndex
 11472  		default:
 11473  			iNdEx = preIndex
 11474  			skippy, err := skip(dAtA[iNdEx:])
 11475  			if err != nil {
 11476  				return err
 11477  			}
 11478  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11479  				return ErrInvalidLength
 11480  			}
 11481  			if (iNdEx + skippy) > l {
 11482  				return io.ErrUnexpectedEOF
 11483  			}
 11484  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11485  			iNdEx += skippy
 11486  		}
 11487  	}
 11488  
 11489  	if iNdEx > l {
 11490  		return io.ErrUnexpectedEOF
 11491  	}
 11492  	return nil
 11493  }
 11494  func (m *EmergencyFailoverShardResponse) UnmarshalVT(dAtA []byte) error {
 11495  	l := len(dAtA)
 11496  	iNdEx := 0
 11497  	for iNdEx < l {
 11498  		preIndex := iNdEx
 11499  		var wire uint64
 11500  		for shift := uint(0); ; shift += 7 {
 11501  			if shift >= 64 {
 11502  				return ErrIntOverflow
 11503  			}
 11504  			if iNdEx >= l {
 11505  				return io.ErrUnexpectedEOF
 11506  			}
 11507  			b := dAtA[iNdEx]
 11508  			iNdEx++
 11509  			wire |= uint64(b&0x7F) << shift
 11510  			if b < 0x80 {
 11511  				break
 11512  			}
 11513  		}
 11514  		fieldNum := int32(wire >> 3)
 11515  		wireType := int(wire & 0x7)
 11516  		if wireType == 4 {
 11517  			return fmt.Errorf("proto: EmergencyFailoverShardResponse: wiretype end group for non-group")
 11518  		}
 11519  		if fieldNum <= 0 {
 11520  			return fmt.Errorf("proto: EmergencyFailoverShardResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11521  		}
 11522  		switch fieldNum {
 11523  		case 1:
 11524  			if wireType != 2 {
 11525  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 11526  			}
 11527  			var msglen int
 11528  			for shift := uint(0); ; shift += 7 {
 11529  				if shift >= 64 {
 11530  					return ErrIntOverflow
 11531  				}
 11532  				if iNdEx >= l {
 11533  					return io.ErrUnexpectedEOF
 11534  				}
 11535  				b := dAtA[iNdEx]
 11536  				iNdEx++
 11537  				msglen |= int(b&0x7F) << shift
 11538  				if b < 0x80 {
 11539  					break
 11540  				}
 11541  			}
 11542  			if msglen < 0 {
 11543  				return ErrInvalidLength
 11544  			}
 11545  			postIndex := iNdEx + msglen
 11546  			if postIndex < 0 {
 11547  				return ErrInvalidLength
 11548  			}
 11549  			if postIndex > l {
 11550  				return io.ErrUnexpectedEOF
 11551  			}
 11552  			if m.Cluster == nil {
 11553  				m.Cluster = &Cluster{}
 11554  			}
 11555  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11556  				return err
 11557  			}
 11558  			iNdEx = postIndex
 11559  		case 2:
 11560  			if wireType != 2 {
 11561  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 11562  			}
 11563  			var stringLen uint64
 11564  			for shift := uint(0); ; shift += 7 {
 11565  				if shift >= 64 {
 11566  					return ErrIntOverflow
 11567  				}
 11568  				if iNdEx >= l {
 11569  					return io.ErrUnexpectedEOF
 11570  				}
 11571  				b := dAtA[iNdEx]
 11572  				iNdEx++
 11573  				stringLen |= uint64(b&0x7F) << shift
 11574  				if b < 0x80 {
 11575  					break
 11576  				}
 11577  			}
 11578  			intStringLen := int(stringLen)
 11579  			if intStringLen < 0 {
 11580  				return ErrInvalidLength
 11581  			}
 11582  			postIndex := iNdEx + intStringLen
 11583  			if postIndex < 0 {
 11584  				return ErrInvalidLength
 11585  			}
 11586  			if postIndex > l {
 11587  				return io.ErrUnexpectedEOF
 11588  			}
 11589  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 11590  			iNdEx = postIndex
 11591  		case 3:
 11592  			if wireType != 2 {
 11593  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 11594  			}
 11595  			var stringLen uint64
 11596  			for shift := uint(0); ; shift += 7 {
 11597  				if shift >= 64 {
 11598  					return ErrIntOverflow
 11599  				}
 11600  				if iNdEx >= l {
 11601  					return io.ErrUnexpectedEOF
 11602  				}
 11603  				b := dAtA[iNdEx]
 11604  				iNdEx++
 11605  				stringLen |= uint64(b&0x7F) << shift
 11606  				if b < 0x80 {
 11607  					break
 11608  				}
 11609  			}
 11610  			intStringLen := int(stringLen)
 11611  			if intStringLen < 0 {
 11612  				return ErrInvalidLength
 11613  			}
 11614  			postIndex := iNdEx + intStringLen
 11615  			if postIndex < 0 {
 11616  				return ErrInvalidLength
 11617  			}
 11618  			if postIndex > l {
 11619  				return io.ErrUnexpectedEOF
 11620  			}
 11621  			m.Shard = string(dAtA[iNdEx:postIndex])
 11622  			iNdEx = postIndex
 11623  		case 4:
 11624  			if wireType != 2 {
 11625  				return fmt.Errorf("proto: wrong wireType = %d for field PromotedPrimary", wireType)
 11626  			}
 11627  			var msglen int
 11628  			for shift := uint(0); ; shift += 7 {
 11629  				if shift >= 64 {
 11630  					return ErrIntOverflow
 11631  				}
 11632  				if iNdEx >= l {
 11633  					return io.ErrUnexpectedEOF
 11634  				}
 11635  				b := dAtA[iNdEx]
 11636  				iNdEx++
 11637  				msglen |= int(b&0x7F) << shift
 11638  				if b < 0x80 {
 11639  					break
 11640  				}
 11641  			}
 11642  			if msglen < 0 {
 11643  				return ErrInvalidLength
 11644  			}
 11645  			postIndex := iNdEx + msglen
 11646  			if postIndex < 0 {
 11647  				return ErrInvalidLength
 11648  			}
 11649  			if postIndex > l {
 11650  				return io.ErrUnexpectedEOF
 11651  			}
 11652  			if m.PromotedPrimary == nil {
 11653  				m.PromotedPrimary = &topodata.TabletAlias{}
 11654  			}
 11655  			if err := m.PromotedPrimary.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11656  				return err
 11657  			}
 11658  			iNdEx = postIndex
 11659  		case 5:
 11660  			if wireType != 2 {
 11661  				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 11662  			}
 11663  			var msglen int
 11664  			for shift := uint(0); ; shift += 7 {
 11665  				if shift >= 64 {
 11666  					return ErrIntOverflow
 11667  				}
 11668  				if iNdEx >= l {
 11669  					return io.ErrUnexpectedEOF
 11670  				}
 11671  				b := dAtA[iNdEx]
 11672  				iNdEx++
 11673  				msglen |= int(b&0x7F) << shift
 11674  				if b < 0x80 {
 11675  					break
 11676  				}
 11677  			}
 11678  			if msglen < 0 {
 11679  				return ErrInvalidLength
 11680  			}
 11681  			postIndex := iNdEx + msglen
 11682  			if postIndex < 0 {
 11683  				return ErrInvalidLength
 11684  			}
 11685  			if postIndex > l {
 11686  				return io.ErrUnexpectedEOF
 11687  			}
 11688  			m.Events = append(m.Events, &logutil.Event{})
 11689  			if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11690  				return err
 11691  			}
 11692  			iNdEx = postIndex
 11693  		default:
 11694  			iNdEx = preIndex
 11695  			skippy, err := skip(dAtA[iNdEx:])
 11696  			if err != nil {
 11697  				return err
 11698  			}
 11699  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11700  				return ErrInvalidLength
 11701  			}
 11702  			if (iNdEx + skippy) > l {
 11703  				return io.ErrUnexpectedEOF
 11704  			}
 11705  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11706  			iNdEx += skippy
 11707  		}
 11708  	}
 11709  
 11710  	if iNdEx > l {
 11711  		return io.ErrUnexpectedEOF
 11712  	}
 11713  	return nil
 11714  }
 11715  func (m *FindSchemaRequest) UnmarshalVT(dAtA []byte) error {
 11716  	l := len(dAtA)
 11717  	iNdEx := 0
 11718  	for iNdEx < l {
 11719  		preIndex := iNdEx
 11720  		var wire uint64
 11721  		for shift := uint(0); ; shift += 7 {
 11722  			if shift >= 64 {
 11723  				return ErrIntOverflow
 11724  			}
 11725  			if iNdEx >= l {
 11726  				return io.ErrUnexpectedEOF
 11727  			}
 11728  			b := dAtA[iNdEx]
 11729  			iNdEx++
 11730  			wire |= uint64(b&0x7F) << shift
 11731  			if b < 0x80 {
 11732  				break
 11733  			}
 11734  		}
 11735  		fieldNum := int32(wire >> 3)
 11736  		wireType := int(wire & 0x7)
 11737  		if wireType == 4 {
 11738  			return fmt.Errorf("proto: FindSchemaRequest: wiretype end group for non-group")
 11739  		}
 11740  		if fieldNum <= 0 {
 11741  			return fmt.Errorf("proto: FindSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11742  		}
 11743  		switch fieldNum {
 11744  		case 1:
 11745  			if wireType != 2 {
 11746  				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
 11747  			}
 11748  			var stringLen uint64
 11749  			for shift := uint(0); ; shift += 7 {
 11750  				if shift >= 64 {
 11751  					return ErrIntOverflow
 11752  				}
 11753  				if iNdEx >= l {
 11754  					return io.ErrUnexpectedEOF
 11755  				}
 11756  				b := dAtA[iNdEx]
 11757  				iNdEx++
 11758  				stringLen |= uint64(b&0x7F) << shift
 11759  				if b < 0x80 {
 11760  					break
 11761  				}
 11762  			}
 11763  			intStringLen := int(stringLen)
 11764  			if intStringLen < 0 {
 11765  				return ErrInvalidLength
 11766  			}
 11767  			postIndex := iNdEx + intStringLen
 11768  			if postIndex < 0 {
 11769  				return ErrInvalidLength
 11770  			}
 11771  			if postIndex > l {
 11772  				return io.ErrUnexpectedEOF
 11773  			}
 11774  			m.Table = string(dAtA[iNdEx:postIndex])
 11775  			iNdEx = postIndex
 11776  		case 2:
 11777  			if wireType != 2 {
 11778  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 11779  			}
 11780  			var stringLen uint64
 11781  			for shift := uint(0); ; shift += 7 {
 11782  				if shift >= 64 {
 11783  					return ErrIntOverflow
 11784  				}
 11785  				if iNdEx >= l {
 11786  					return io.ErrUnexpectedEOF
 11787  				}
 11788  				b := dAtA[iNdEx]
 11789  				iNdEx++
 11790  				stringLen |= uint64(b&0x7F) << shift
 11791  				if b < 0x80 {
 11792  					break
 11793  				}
 11794  			}
 11795  			intStringLen := int(stringLen)
 11796  			if intStringLen < 0 {
 11797  				return ErrInvalidLength
 11798  			}
 11799  			postIndex := iNdEx + intStringLen
 11800  			if postIndex < 0 {
 11801  				return ErrInvalidLength
 11802  			}
 11803  			if postIndex > l {
 11804  				return io.ErrUnexpectedEOF
 11805  			}
 11806  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 11807  			iNdEx = postIndex
 11808  		case 3:
 11809  			if wireType != 2 {
 11810  				return fmt.Errorf("proto: wrong wireType = %d for field TableSizeOptions", wireType)
 11811  			}
 11812  			var msglen int
 11813  			for shift := uint(0); ; shift += 7 {
 11814  				if shift >= 64 {
 11815  					return ErrIntOverflow
 11816  				}
 11817  				if iNdEx >= l {
 11818  					return io.ErrUnexpectedEOF
 11819  				}
 11820  				b := dAtA[iNdEx]
 11821  				iNdEx++
 11822  				msglen |= int(b&0x7F) << shift
 11823  				if b < 0x80 {
 11824  					break
 11825  				}
 11826  			}
 11827  			if msglen < 0 {
 11828  				return ErrInvalidLength
 11829  			}
 11830  			postIndex := iNdEx + msglen
 11831  			if postIndex < 0 {
 11832  				return ErrInvalidLength
 11833  			}
 11834  			if postIndex > l {
 11835  				return io.ErrUnexpectedEOF
 11836  			}
 11837  			if m.TableSizeOptions == nil {
 11838  				m.TableSizeOptions = &GetSchemaTableSizeOptions{}
 11839  			}
 11840  			if err := m.TableSizeOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11841  				return err
 11842  			}
 11843  			iNdEx = postIndex
 11844  		default:
 11845  			iNdEx = preIndex
 11846  			skippy, err := skip(dAtA[iNdEx:])
 11847  			if err != nil {
 11848  				return err
 11849  			}
 11850  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11851  				return ErrInvalidLength
 11852  			}
 11853  			if (iNdEx + skippy) > l {
 11854  				return io.ErrUnexpectedEOF
 11855  			}
 11856  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11857  			iNdEx += skippy
 11858  		}
 11859  	}
 11860  
 11861  	if iNdEx > l {
 11862  		return io.ErrUnexpectedEOF
 11863  	}
 11864  	return nil
 11865  }
 11866  func (m *GetBackupsRequest) UnmarshalVT(dAtA []byte) error {
 11867  	l := len(dAtA)
 11868  	iNdEx := 0
 11869  	for iNdEx < l {
 11870  		preIndex := iNdEx
 11871  		var wire uint64
 11872  		for shift := uint(0); ; shift += 7 {
 11873  			if shift >= 64 {
 11874  				return ErrIntOverflow
 11875  			}
 11876  			if iNdEx >= l {
 11877  				return io.ErrUnexpectedEOF
 11878  			}
 11879  			b := dAtA[iNdEx]
 11880  			iNdEx++
 11881  			wire |= uint64(b&0x7F) << shift
 11882  			if b < 0x80 {
 11883  				break
 11884  			}
 11885  		}
 11886  		fieldNum := int32(wire >> 3)
 11887  		wireType := int(wire & 0x7)
 11888  		if wireType == 4 {
 11889  			return fmt.Errorf("proto: GetBackupsRequest: wiretype end group for non-group")
 11890  		}
 11891  		if fieldNum <= 0 {
 11892  			return fmt.Errorf("proto: GetBackupsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11893  		}
 11894  		switch fieldNum {
 11895  		case 1:
 11896  			if wireType != 2 {
 11897  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 11898  			}
 11899  			var stringLen uint64
 11900  			for shift := uint(0); ; shift += 7 {
 11901  				if shift >= 64 {
 11902  					return ErrIntOverflow
 11903  				}
 11904  				if iNdEx >= l {
 11905  					return io.ErrUnexpectedEOF
 11906  				}
 11907  				b := dAtA[iNdEx]
 11908  				iNdEx++
 11909  				stringLen |= uint64(b&0x7F) << shift
 11910  				if b < 0x80 {
 11911  					break
 11912  				}
 11913  			}
 11914  			intStringLen := int(stringLen)
 11915  			if intStringLen < 0 {
 11916  				return ErrInvalidLength
 11917  			}
 11918  			postIndex := iNdEx + intStringLen
 11919  			if postIndex < 0 {
 11920  				return ErrInvalidLength
 11921  			}
 11922  			if postIndex > l {
 11923  				return io.ErrUnexpectedEOF
 11924  			}
 11925  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 11926  			iNdEx = postIndex
 11927  		case 2:
 11928  			if wireType != 2 {
 11929  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspaces", wireType)
 11930  			}
 11931  			var stringLen uint64
 11932  			for shift := uint(0); ; shift += 7 {
 11933  				if shift >= 64 {
 11934  					return ErrIntOverflow
 11935  				}
 11936  				if iNdEx >= l {
 11937  					return io.ErrUnexpectedEOF
 11938  				}
 11939  				b := dAtA[iNdEx]
 11940  				iNdEx++
 11941  				stringLen |= uint64(b&0x7F) << shift
 11942  				if b < 0x80 {
 11943  					break
 11944  				}
 11945  			}
 11946  			intStringLen := int(stringLen)
 11947  			if intStringLen < 0 {
 11948  				return ErrInvalidLength
 11949  			}
 11950  			postIndex := iNdEx + intStringLen
 11951  			if postIndex < 0 {
 11952  				return ErrInvalidLength
 11953  			}
 11954  			if postIndex > l {
 11955  				return io.ErrUnexpectedEOF
 11956  			}
 11957  			m.Keyspaces = append(m.Keyspaces, string(dAtA[iNdEx:postIndex]))
 11958  			iNdEx = postIndex
 11959  		case 3:
 11960  			if wireType != 2 {
 11961  				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceShards", wireType)
 11962  			}
 11963  			var stringLen uint64
 11964  			for shift := uint(0); ; shift += 7 {
 11965  				if shift >= 64 {
 11966  					return ErrIntOverflow
 11967  				}
 11968  				if iNdEx >= l {
 11969  					return io.ErrUnexpectedEOF
 11970  				}
 11971  				b := dAtA[iNdEx]
 11972  				iNdEx++
 11973  				stringLen |= uint64(b&0x7F) << shift
 11974  				if b < 0x80 {
 11975  					break
 11976  				}
 11977  			}
 11978  			intStringLen := int(stringLen)
 11979  			if intStringLen < 0 {
 11980  				return ErrInvalidLength
 11981  			}
 11982  			postIndex := iNdEx + intStringLen
 11983  			if postIndex < 0 {
 11984  				return ErrInvalidLength
 11985  			}
 11986  			if postIndex > l {
 11987  				return io.ErrUnexpectedEOF
 11988  			}
 11989  			m.KeyspaceShards = append(m.KeyspaceShards, string(dAtA[iNdEx:postIndex]))
 11990  			iNdEx = postIndex
 11991  		case 4:
 11992  			if wireType != 2 {
 11993  				return fmt.Errorf("proto: wrong wireType = %d for field RequestOptions", wireType)
 11994  			}
 11995  			var msglen int
 11996  			for shift := uint(0); ; shift += 7 {
 11997  				if shift >= 64 {
 11998  					return ErrIntOverflow
 11999  				}
 12000  				if iNdEx >= l {
 12001  					return io.ErrUnexpectedEOF
 12002  				}
 12003  				b := dAtA[iNdEx]
 12004  				iNdEx++
 12005  				msglen |= int(b&0x7F) << shift
 12006  				if b < 0x80 {
 12007  					break
 12008  				}
 12009  			}
 12010  			if msglen < 0 {
 12011  				return ErrInvalidLength
 12012  			}
 12013  			postIndex := iNdEx + msglen
 12014  			if postIndex < 0 {
 12015  				return ErrInvalidLength
 12016  			}
 12017  			if postIndex > l {
 12018  				return io.ErrUnexpectedEOF
 12019  			}
 12020  			if m.RequestOptions == nil {
 12021  				m.RequestOptions = &vtctldata.GetBackupsRequest{}
 12022  			}
 12023  			if err := m.RequestOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12024  				return err
 12025  			}
 12026  			iNdEx = postIndex
 12027  		default:
 12028  			iNdEx = preIndex
 12029  			skippy, err := skip(dAtA[iNdEx:])
 12030  			if err != nil {
 12031  				return err
 12032  			}
 12033  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12034  				return ErrInvalidLength
 12035  			}
 12036  			if (iNdEx + skippy) > l {
 12037  				return io.ErrUnexpectedEOF
 12038  			}
 12039  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12040  			iNdEx += skippy
 12041  		}
 12042  	}
 12043  
 12044  	if iNdEx > l {
 12045  		return io.ErrUnexpectedEOF
 12046  	}
 12047  	return nil
 12048  }
 12049  func (m *GetBackupsResponse) UnmarshalVT(dAtA []byte) error {
 12050  	l := len(dAtA)
 12051  	iNdEx := 0
 12052  	for iNdEx < l {
 12053  		preIndex := iNdEx
 12054  		var wire uint64
 12055  		for shift := uint(0); ; shift += 7 {
 12056  			if shift >= 64 {
 12057  				return ErrIntOverflow
 12058  			}
 12059  			if iNdEx >= l {
 12060  				return io.ErrUnexpectedEOF
 12061  			}
 12062  			b := dAtA[iNdEx]
 12063  			iNdEx++
 12064  			wire |= uint64(b&0x7F) << shift
 12065  			if b < 0x80 {
 12066  				break
 12067  			}
 12068  		}
 12069  		fieldNum := int32(wire >> 3)
 12070  		wireType := int(wire & 0x7)
 12071  		if wireType == 4 {
 12072  			return fmt.Errorf("proto: GetBackupsResponse: wiretype end group for non-group")
 12073  		}
 12074  		if fieldNum <= 0 {
 12075  			return fmt.Errorf("proto: GetBackupsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12076  		}
 12077  		switch fieldNum {
 12078  		case 1:
 12079  			if wireType != 2 {
 12080  				return fmt.Errorf("proto: wrong wireType = %d for field Backups", wireType)
 12081  			}
 12082  			var msglen int
 12083  			for shift := uint(0); ; shift += 7 {
 12084  				if shift >= 64 {
 12085  					return ErrIntOverflow
 12086  				}
 12087  				if iNdEx >= l {
 12088  					return io.ErrUnexpectedEOF
 12089  				}
 12090  				b := dAtA[iNdEx]
 12091  				iNdEx++
 12092  				msglen |= int(b&0x7F) << shift
 12093  				if b < 0x80 {
 12094  					break
 12095  				}
 12096  			}
 12097  			if msglen < 0 {
 12098  				return ErrInvalidLength
 12099  			}
 12100  			postIndex := iNdEx + msglen
 12101  			if postIndex < 0 {
 12102  				return ErrInvalidLength
 12103  			}
 12104  			if postIndex > l {
 12105  				return io.ErrUnexpectedEOF
 12106  			}
 12107  			m.Backups = append(m.Backups, &ClusterBackup{})
 12108  			if err := m.Backups[len(m.Backups)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12109  				return err
 12110  			}
 12111  			iNdEx = postIndex
 12112  		default:
 12113  			iNdEx = preIndex
 12114  			skippy, err := skip(dAtA[iNdEx:])
 12115  			if err != nil {
 12116  				return err
 12117  			}
 12118  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12119  				return ErrInvalidLength
 12120  			}
 12121  			if (iNdEx + skippy) > l {
 12122  				return io.ErrUnexpectedEOF
 12123  			}
 12124  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12125  			iNdEx += skippy
 12126  		}
 12127  	}
 12128  
 12129  	if iNdEx > l {
 12130  		return io.ErrUnexpectedEOF
 12131  	}
 12132  	return nil
 12133  }
 12134  func (m *GetCellInfosRequest) UnmarshalVT(dAtA []byte) error {
 12135  	l := len(dAtA)
 12136  	iNdEx := 0
 12137  	for iNdEx < l {
 12138  		preIndex := iNdEx
 12139  		var wire uint64
 12140  		for shift := uint(0); ; shift += 7 {
 12141  			if shift >= 64 {
 12142  				return ErrIntOverflow
 12143  			}
 12144  			if iNdEx >= l {
 12145  				return io.ErrUnexpectedEOF
 12146  			}
 12147  			b := dAtA[iNdEx]
 12148  			iNdEx++
 12149  			wire |= uint64(b&0x7F) << shift
 12150  			if b < 0x80 {
 12151  				break
 12152  			}
 12153  		}
 12154  		fieldNum := int32(wire >> 3)
 12155  		wireType := int(wire & 0x7)
 12156  		if wireType == 4 {
 12157  			return fmt.Errorf("proto: GetCellInfosRequest: wiretype end group for non-group")
 12158  		}
 12159  		if fieldNum <= 0 {
 12160  			return fmt.Errorf("proto: GetCellInfosRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12161  		}
 12162  		switch fieldNum {
 12163  		case 1:
 12164  			if wireType != 2 {
 12165  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 12166  			}
 12167  			var stringLen uint64
 12168  			for shift := uint(0); ; shift += 7 {
 12169  				if shift >= 64 {
 12170  					return ErrIntOverflow
 12171  				}
 12172  				if iNdEx >= l {
 12173  					return io.ErrUnexpectedEOF
 12174  				}
 12175  				b := dAtA[iNdEx]
 12176  				iNdEx++
 12177  				stringLen |= uint64(b&0x7F) << shift
 12178  				if b < 0x80 {
 12179  					break
 12180  				}
 12181  			}
 12182  			intStringLen := int(stringLen)
 12183  			if intStringLen < 0 {
 12184  				return ErrInvalidLength
 12185  			}
 12186  			postIndex := iNdEx + intStringLen
 12187  			if postIndex < 0 {
 12188  				return ErrInvalidLength
 12189  			}
 12190  			if postIndex > l {
 12191  				return io.ErrUnexpectedEOF
 12192  			}
 12193  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 12194  			iNdEx = postIndex
 12195  		case 2:
 12196  			if wireType != 2 {
 12197  				return fmt.Errorf("proto: wrong wireType = %d for field Cells", wireType)
 12198  			}
 12199  			var stringLen uint64
 12200  			for shift := uint(0); ; shift += 7 {
 12201  				if shift >= 64 {
 12202  					return ErrIntOverflow
 12203  				}
 12204  				if iNdEx >= l {
 12205  					return io.ErrUnexpectedEOF
 12206  				}
 12207  				b := dAtA[iNdEx]
 12208  				iNdEx++
 12209  				stringLen |= uint64(b&0x7F) << shift
 12210  				if b < 0x80 {
 12211  					break
 12212  				}
 12213  			}
 12214  			intStringLen := int(stringLen)
 12215  			if intStringLen < 0 {
 12216  				return ErrInvalidLength
 12217  			}
 12218  			postIndex := iNdEx + intStringLen
 12219  			if postIndex < 0 {
 12220  				return ErrInvalidLength
 12221  			}
 12222  			if postIndex > l {
 12223  				return io.ErrUnexpectedEOF
 12224  			}
 12225  			m.Cells = append(m.Cells, string(dAtA[iNdEx:postIndex]))
 12226  			iNdEx = postIndex
 12227  		case 3:
 12228  			if wireType != 0 {
 12229  				return fmt.Errorf("proto: wrong wireType = %d for field NamesOnly", wireType)
 12230  			}
 12231  			var v int
 12232  			for shift := uint(0); ; shift += 7 {
 12233  				if shift >= 64 {
 12234  					return ErrIntOverflow
 12235  				}
 12236  				if iNdEx >= l {
 12237  					return io.ErrUnexpectedEOF
 12238  				}
 12239  				b := dAtA[iNdEx]
 12240  				iNdEx++
 12241  				v |= int(b&0x7F) << shift
 12242  				if b < 0x80 {
 12243  					break
 12244  				}
 12245  			}
 12246  			m.NamesOnly = bool(v != 0)
 12247  		default:
 12248  			iNdEx = preIndex
 12249  			skippy, err := skip(dAtA[iNdEx:])
 12250  			if err != nil {
 12251  				return err
 12252  			}
 12253  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12254  				return ErrInvalidLength
 12255  			}
 12256  			if (iNdEx + skippy) > l {
 12257  				return io.ErrUnexpectedEOF
 12258  			}
 12259  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12260  			iNdEx += skippy
 12261  		}
 12262  	}
 12263  
 12264  	if iNdEx > l {
 12265  		return io.ErrUnexpectedEOF
 12266  	}
 12267  	return nil
 12268  }
 12269  func (m *GetCellInfosResponse) UnmarshalVT(dAtA []byte) error {
 12270  	l := len(dAtA)
 12271  	iNdEx := 0
 12272  	for iNdEx < l {
 12273  		preIndex := iNdEx
 12274  		var wire uint64
 12275  		for shift := uint(0); ; shift += 7 {
 12276  			if shift >= 64 {
 12277  				return ErrIntOverflow
 12278  			}
 12279  			if iNdEx >= l {
 12280  				return io.ErrUnexpectedEOF
 12281  			}
 12282  			b := dAtA[iNdEx]
 12283  			iNdEx++
 12284  			wire |= uint64(b&0x7F) << shift
 12285  			if b < 0x80 {
 12286  				break
 12287  			}
 12288  		}
 12289  		fieldNum := int32(wire >> 3)
 12290  		wireType := int(wire & 0x7)
 12291  		if wireType == 4 {
 12292  			return fmt.Errorf("proto: GetCellInfosResponse: wiretype end group for non-group")
 12293  		}
 12294  		if fieldNum <= 0 {
 12295  			return fmt.Errorf("proto: GetCellInfosResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12296  		}
 12297  		switch fieldNum {
 12298  		case 1:
 12299  			if wireType != 2 {
 12300  				return fmt.Errorf("proto: wrong wireType = %d for field CellInfos", wireType)
 12301  			}
 12302  			var msglen int
 12303  			for shift := uint(0); ; shift += 7 {
 12304  				if shift >= 64 {
 12305  					return ErrIntOverflow
 12306  				}
 12307  				if iNdEx >= l {
 12308  					return io.ErrUnexpectedEOF
 12309  				}
 12310  				b := dAtA[iNdEx]
 12311  				iNdEx++
 12312  				msglen |= int(b&0x7F) << shift
 12313  				if b < 0x80 {
 12314  					break
 12315  				}
 12316  			}
 12317  			if msglen < 0 {
 12318  				return ErrInvalidLength
 12319  			}
 12320  			postIndex := iNdEx + msglen
 12321  			if postIndex < 0 {
 12322  				return ErrInvalidLength
 12323  			}
 12324  			if postIndex > l {
 12325  				return io.ErrUnexpectedEOF
 12326  			}
 12327  			m.CellInfos = append(m.CellInfos, &ClusterCellInfo{})
 12328  			if err := m.CellInfos[len(m.CellInfos)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12329  				return err
 12330  			}
 12331  			iNdEx = postIndex
 12332  		default:
 12333  			iNdEx = preIndex
 12334  			skippy, err := skip(dAtA[iNdEx:])
 12335  			if err != nil {
 12336  				return err
 12337  			}
 12338  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12339  				return ErrInvalidLength
 12340  			}
 12341  			if (iNdEx + skippy) > l {
 12342  				return io.ErrUnexpectedEOF
 12343  			}
 12344  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12345  			iNdEx += skippy
 12346  		}
 12347  	}
 12348  
 12349  	if iNdEx > l {
 12350  		return io.ErrUnexpectedEOF
 12351  	}
 12352  	return nil
 12353  }
 12354  func (m *GetCellsAliasesRequest) UnmarshalVT(dAtA []byte) error {
 12355  	l := len(dAtA)
 12356  	iNdEx := 0
 12357  	for iNdEx < l {
 12358  		preIndex := iNdEx
 12359  		var wire uint64
 12360  		for shift := uint(0); ; shift += 7 {
 12361  			if shift >= 64 {
 12362  				return ErrIntOverflow
 12363  			}
 12364  			if iNdEx >= l {
 12365  				return io.ErrUnexpectedEOF
 12366  			}
 12367  			b := dAtA[iNdEx]
 12368  			iNdEx++
 12369  			wire |= uint64(b&0x7F) << shift
 12370  			if b < 0x80 {
 12371  				break
 12372  			}
 12373  		}
 12374  		fieldNum := int32(wire >> 3)
 12375  		wireType := int(wire & 0x7)
 12376  		if wireType == 4 {
 12377  			return fmt.Errorf("proto: GetCellsAliasesRequest: wiretype end group for non-group")
 12378  		}
 12379  		if fieldNum <= 0 {
 12380  			return fmt.Errorf("proto: GetCellsAliasesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12381  		}
 12382  		switch fieldNum {
 12383  		case 1:
 12384  			if wireType != 2 {
 12385  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 12386  			}
 12387  			var stringLen uint64
 12388  			for shift := uint(0); ; shift += 7 {
 12389  				if shift >= 64 {
 12390  					return ErrIntOverflow
 12391  				}
 12392  				if iNdEx >= l {
 12393  					return io.ErrUnexpectedEOF
 12394  				}
 12395  				b := dAtA[iNdEx]
 12396  				iNdEx++
 12397  				stringLen |= uint64(b&0x7F) << shift
 12398  				if b < 0x80 {
 12399  					break
 12400  				}
 12401  			}
 12402  			intStringLen := int(stringLen)
 12403  			if intStringLen < 0 {
 12404  				return ErrInvalidLength
 12405  			}
 12406  			postIndex := iNdEx + intStringLen
 12407  			if postIndex < 0 {
 12408  				return ErrInvalidLength
 12409  			}
 12410  			if postIndex > l {
 12411  				return io.ErrUnexpectedEOF
 12412  			}
 12413  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 12414  			iNdEx = postIndex
 12415  		default:
 12416  			iNdEx = preIndex
 12417  			skippy, err := skip(dAtA[iNdEx:])
 12418  			if err != nil {
 12419  				return err
 12420  			}
 12421  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12422  				return ErrInvalidLength
 12423  			}
 12424  			if (iNdEx + skippy) > l {
 12425  				return io.ErrUnexpectedEOF
 12426  			}
 12427  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12428  			iNdEx += skippy
 12429  		}
 12430  	}
 12431  
 12432  	if iNdEx > l {
 12433  		return io.ErrUnexpectedEOF
 12434  	}
 12435  	return nil
 12436  }
 12437  func (m *GetCellsAliasesResponse) UnmarshalVT(dAtA []byte) error {
 12438  	l := len(dAtA)
 12439  	iNdEx := 0
 12440  	for iNdEx < l {
 12441  		preIndex := iNdEx
 12442  		var wire uint64
 12443  		for shift := uint(0); ; shift += 7 {
 12444  			if shift >= 64 {
 12445  				return ErrIntOverflow
 12446  			}
 12447  			if iNdEx >= l {
 12448  				return io.ErrUnexpectedEOF
 12449  			}
 12450  			b := dAtA[iNdEx]
 12451  			iNdEx++
 12452  			wire |= uint64(b&0x7F) << shift
 12453  			if b < 0x80 {
 12454  				break
 12455  			}
 12456  		}
 12457  		fieldNum := int32(wire >> 3)
 12458  		wireType := int(wire & 0x7)
 12459  		if wireType == 4 {
 12460  			return fmt.Errorf("proto: GetCellsAliasesResponse: wiretype end group for non-group")
 12461  		}
 12462  		if fieldNum <= 0 {
 12463  			return fmt.Errorf("proto: GetCellsAliasesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12464  		}
 12465  		switch fieldNum {
 12466  		case 1:
 12467  			if wireType != 2 {
 12468  				return fmt.Errorf("proto: wrong wireType = %d for field Aliases", wireType)
 12469  			}
 12470  			var msglen int
 12471  			for shift := uint(0); ; shift += 7 {
 12472  				if shift >= 64 {
 12473  					return ErrIntOverflow
 12474  				}
 12475  				if iNdEx >= l {
 12476  					return io.ErrUnexpectedEOF
 12477  				}
 12478  				b := dAtA[iNdEx]
 12479  				iNdEx++
 12480  				msglen |= int(b&0x7F) << shift
 12481  				if b < 0x80 {
 12482  					break
 12483  				}
 12484  			}
 12485  			if msglen < 0 {
 12486  				return ErrInvalidLength
 12487  			}
 12488  			postIndex := iNdEx + msglen
 12489  			if postIndex < 0 {
 12490  				return ErrInvalidLength
 12491  			}
 12492  			if postIndex > l {
 12493  				return io.ErrUnexpectedEOF
 12494  			}
 12495  			m.Aliases = append(m.Aliases, &ClusterCellsAliases{})
 12496  			if err := m.Aliases[len(m.Aliases)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12497  				return err
 12498  			}
 12499  			iNdEx = postIndex
 12500  		default:
 12501  			iNdEx = preIndex
 12502  			skippy, err := skip(dAtA[iNdEx:])
 12503  			if err != nil {
 12504  				return err
 12505  			}
 12506  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12507  				return ErrInvalidLength
 12508  			}
 12509  			if (iNdEx + skippy) > l {
 12510  				return io.ErrUnexpectedEOF
 12511  			}
 12512  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12513  			iNdEx += skippy
 12514  		}
 12515  	}
 12516  
 12517  	if iNdEx > l {
 12518  		return io.ErrUnexpectedEOF
 12519  	}
 12520  	return nil
 12521  }
 12522  func (m *GetClustersRequest) UnmarshalVT(dAtA []byte) error {
 12523  	l := len(dAtA)
 12524  	iNdEx := 0
 12525  	for iNdEx < l {
 12526  		preIndex := iNdEx
 12527  		var wire uint64
 12528  		for shift := uint(0); ; shift += 7 {
 12529  			if shift >= 64 {
 12530  				return ErrIntOverflow
 12531  			}
 12532  			if iNdEx >= l {
 12533  				return io.ErrUnexpectedEOF
 12534  			}
 12535  			b := dAtA[iNdEx]
 12536  			iNdEx++
 12537  			wire |= uint64(b&0x7F) << shift
 12538  			if b < 0x80 {
 12539  				break
 12540  			}
 12541  		}
 12542  		fieldNum := int32(wire >> 3)
 12543  		wireType := int(wire & 0x7)
 12544  		if wireType == 4 {
 12545  			return fmt.Errorf("proto: GetClustersRequest: wiretype end group for non-group")
 12546  		}
 12547  		if fieldNum <= 0 {
 12548  			return fmt.Errorf("proto: GetClustersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12549  		}
 12550  		switch fieldNum {
 12551  		default:
 12552  			iNdEx = preIndex
 12553  			skippy, err := skip(dAtA[iNdEx:])
 12554  			if err != nil {
 12555  				return err
 12556  			}
 12557  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12558  				return ErrInvalidLength
 12559  			}
 12560  			if (iNdEx + skippy) > l {
 12561  				return io.ErrUnexpectedEOF
 12562  			}
 12563  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12564  			iNdEx += skippy
 12565  		}
 12566  	}
 12567  
 12568  	if iNdEx > l {
 12569  		return io.ErrUnexpectedEOF
 12570  	}
 12571  	return nil
 12572  }
 12573  func (m *GetClustersResponse) UnmarshalVT(dAtA []byte) error {
 12574  	l := len(dAtA)
 12575  	iNdEx := 0
 12576  	for iNdEx < l {
 12577  		preIndex := iNdEx
 12578  		var wire uint64
 12579  		for shift := uint(0); ; shift += 7 {
 12580  			if shift >= 64 {
 12581  				return ErrIntOverflow
 12582  			}
 12583  			if iNdEx >= l {
 12584  				return io.ErrUnexpectedEOF
 12585  			}
 12586  			b := dAtA[iNdEx]
 12587  			iNdEx++
 12588  			wire |= uint64(b&0x7F) << shift
 12589  			if b < 0x80 {
 12590  				break
 12591  			}
 12592  		}
 12593  		fieldNum := int32(wire >> 3)
 12594  		wireType := int(wire & 0x7)
 12595  		if wireType == 4 {
 12596  			return fmt.Errorf("proto: GetClustersResponse: wiretype end group for non-group")
 12597  		}
 12598  		if fieldNum <= 0 {
 12599  			return fmt.Errorf("proto: GetClustersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12600  		}
 12601  		switch fieldNum {
 12602  		case 1:
 12603  			if wireType != 2 {
 12604  				return fmt.Errorf("proto: wrong wireType = %d for field Clusters", wireType)
 12605  			}
 12606  			var msglen int
 12607  			for shift := uint(0); ; shift += 7 {
 12608  				if shift >= 64 {
 12609  					return ErrIntOverflow
 12610  				}
 12611  				if iNdEx >= l {
 12612  					return io.ErrUnexpectedEOF
 12613  				}
 12614  				b := dAtA[iNdEx]
 12615  				iNdEx++
 12616  				msglen |= int(b&0x7F) << shift
 12617  				if b < 0x80 {
 12618  					break
 12619  				}
 12620  			}
 12621  			if msglen < 0 {
 12622  				return ErrInvalidLength
 12623  			}
 12624  			postIndex := iNdEx + msglen
 12625  			if postIndex < 0 {
 12626  				return ErrInvalidLength
 12627  			}
 12628  			if postIndex > l {
 12629  				return io.ErrUnexpectedEOF
 12630  			}
 12631  			m.Clusters = append(m.Clusters, &Cluster{})
 12632  			if err := m.Clusters[len(m.Clusters)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12633  				return err
 12634  			}
 12635  			iNdEx = postIndex
 12636  		default:
 12637  			iNdEx = preIndex
 12638  			skippy, err := skip(dAtA[iNdEx:])
 12639  			if err != nil {
 12640  				return err
 12641  			}
 12642  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12643  				return ErrInvalidLength
 12644  			}
 12645  			if (iNdEx + skippy) > l {
 12646  				return io.ErrUnexpectedEOF
 12647  			}
 12648  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12649  			iNdEx += skippy
 12650  		}
 12651  	}
 12652  
 12653  	if iNdEx > l {
 12654  		return io.ErrUnexpectedEOF
 12655  	}
 12656  	return nil
 12657  }
 12658  func (m *GetFullStatusRequest) UnmarshalVT(dAtA []byte) error {
 12659  	l := len(dAtA)
 12660  	iNdEx := 0
 12661  	for iNdEx < l {
 12662  		preIndex := iNdEx
 12663  		var wire uint64
 12664  		for shift := uint(0); ; shift += 7 {
 12665  			if shift >= 64 {
 12666  				return ErrIntOverflow
 12667  			}
 12668  			if iNdEx >= l {
 12669  				return io.ErrUnexpectedEOF
 12670  			}
 12671  			b := dAtA[iNdEx]
 12672  			iNdEx++
 12673  			wire |= uint64(b&0x7F) << shift
 12674  			if b < 0x80 {
 12675  				break
 12676  			}
 12677  		}
 12678  		fieldNum := int32(wire >> 3)
 12679  		wireType := int(wire & 0x7)
 12680  		if wireType == 4 {
 12681  			return fmt.Errorf("proto: GetFullStatusRequest: wiretype end group for non-group")
 12682  		}
 12683  		if fieldNum <= 0 {
 12684  			return fmt.Errorf("proto: GetFullStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12685  		}
 12686  		switch fieldNum {
 12687  		case 1:
 12688  			if wireType != 2 {
 12689  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 12690  			}
 12691  			var stringLen uint64
 12692  			for shift := uint(0); ; shift += 7 {
 12693  				if shift >= 64 {
 12694  					return ErrIntOverflow
 12695  				}
 12696  				if iNdEx >= l {
 12697  					return io.ErrUnexpectedEOF
 12698  				}
 12699  				b := dAtA[iNdEx]
 12700  				iNdEx++
 12701  				stringLen |= uint64(b&0x7F) << shift
 12702  				if b < 0x80 {
 12703  					break
 12704  				}
 12705  			}
 12706  			intStringLen := int(stringLen)
 12707  			if intStringLen < 0 {
 12708  				return ErrInvalidLength
 12709  			}
 12710  			postIndex := iNdEx + intStringLen
 12711  			if postIndex < 0 {
 12712  				return ErrInvalidLength
 12713  			}
 12714  			if postIndex > l {
 12715  				return io.ErrUnexpectedEOF
 12716  			}
 12717  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 12718  			iNdEx = postIndex
 12719  		case 2:
 12720  			if wireType != 2 {
 12721  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 12722  			}
 12723  			var msglen int
 12724  			for shift := uint(0); ; shift += 7 {
 12725  				if shift >= 64 {
 12726  					return ErrIntOverflow
 12727  				}
 12728  				if iNdEx >= l {
 12729  					return io.ErrUnexpectedEOF
 12730  				}
 12731  				b := dAtA[iNdEx]
 12732  				iNdEx++
 12733  				msglen |= int(b&0x7F) << shift
 12734  				if b < 0x80 {
 12735  					break
 12736  				}
 12737  			}
 12738  			if msglen < 0 {
 12739  				return ErrInvalidLength
 12740  			}
 12741  			postIndex := iNdEx + msglen
 12742  			if postIndex < 0 {
 12743  				return ErrInvalidLength
 12744  			}
 12745  			if postIndex > l {
 12746  				return io.ErrUnexpectedEOF
 12747  			}
 12748  			if m.Alias == nil {
 12749  				m.Alias = &topodata.TabletAlias{}
 12750  			}
 12751  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12752  				return err
 12753  			}
 12754  			iNdEx = postIndex
 12755  		default:
 12756  			iNdEx = preIndex
 12757  			skippy, err := skip(dAtA[iNdEx:])
 12758  			if err != nil {
 12759  				return err
 12760  			}
 12761  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12762  				return ErrInvalidLength
 12763  			}
 12764  			if (iNdEx + skippy) > l {
 12765  				return io.ErrUnexpectedEOF
 12766  			}
 12767  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12768  			iNdEx += skippy
 12769  		}
 12770  	}
 12771  
 12772  	if iNdEx > l {
 12773  		return io.ErrUnexpectedEOF
 12774  	}
 12775  	return nil
 12776  }
 12777  func (m *GetGatesRequest) UnmarshalVT(dAtA []byte) error {
 12778  	l := len(dAtA)
 12779  	iNdEx := 0
 12780  	for iNdEx < l {
 12781  		preIndex := iNdEx
 12782  		var wire uint64
 12783  		for shift := uint(0); ; shift += 7 {
 12784  			if shift >= 64 {
 12785  				return ErrIntOverflow
 12786  			}
 12787  			if iNdEx >= l {
 12788  				return io.ErrUnexpectedEOF
 12789  			}
 12790  			b := dAtA[iNdEx]
 12791  			iNdEx++
 12792  			wire |= uint64(b&0x7F) << shift
 12793  			if b < 0x80 {
 12794  				break
 12795  			}
 12796  		}
 12797  		fieldNum := int32(wire >> 3)
 12798  		wireType := int(wire & 0x7)
 12799  		if wireType == 4 {
 12800  			return fmt.Errorf("proto: GetGatesRequest: wiretype end group for non-group")
 12801  		}
 12802  		if fieldNum <= 0 {
 12803  			return fmt.Errorf("proto: GetGatesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12804  		}
 12805  		switch fieldNum {
 12806  		case 1:
 12807  			if wireType != 2 {
 12808  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 12809  			}
 12810  			var stringLen uint64
 12811  			for shift := uint(0); ; shift += 7 {
 12812  				if shift >= 64 {
 12813  					return ErrIntOverflow
 12814  				}
 12815  				if iNdEx >= l {
 12816  					return io.ErrUnexpectedEOF
 12817  				}
 12818  				b := dAtA[iNdEx]
 12819  				iNdEx++
 12820  				stringLen |= uint64(b&0x7F) << shift
 12821  				if b < 0x80 {
 12822  					break
 12823  				}
 12824  			}
 12825  			intStringLen := int(stringLen)
 12826  			if intStringLen < 0 {
 12827  				return ErrInvalidLength
 12828  			}
 12829  			postIndex := iNdEx + intStringLen
 12830  			if postIndex < 0 {
 12831  				return ErrInvalidLength
 12832  			}
 12833  			if postIndex > l {
 12834  				return io.ErrUnexpectedEOF
 12835  			}
 12836  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 12837  			iNdEx = postIndex
 12838  		default:
 12839  			iNdEx = preIndex
 12840  			skippy, err := skip(dAtA[iNdEx:])
 12841  			if err != nil {
 12842  				return err
 12843  			}
 12844  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12845  				return ErrInvalidLength
 12846  			}
 12847  			if (iNdEx + skippy) > l {
 12848  				return io.ErrUnexpectedEOF
 12849  			}
 12850  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12851  			iNdEx += skippy
 12852  		}
 12853  	}
 12854  
 12855  	if iNdEx > l {
 12856  		return io.ErrUnexpectedEOF
 12857  	}
 12858  	return nil
 12859  }
 12860  func (m *GetGatesResponse) UnmarshalVT(dAtA []byte) error {
 12861  	l := len(dAtA)
 12862  	iNdEx := 0
 12863  	for iNdEx < l {
 12864  		preIndex := iNdEx
 12865  		var wire uint64
 12866  		for shift := uint(0); ; shift += 7 {
 12867  			if shift >= 64 {
 12868  				return ErrIntOverflow
 12869  			}
 12870  			if iNdEx >= l {
 12871  				return io.ErrUnexpectedEOF
 12872  			}
 12873  			b := dAtA[iNdEx]
 12874  			iNdEx++
 12875  			wire |= uint64(b&0x7F) << shift
 12876  			if b < 0x80 {
 12877  				break
 12878  			}
 12879  		}
 12880  		fieldNum := int32(wire >> 3)
 12881  		wireType := int(wire & 0x7)
 12882  		if wireType == 4 {
 12883  			return fmt.Errorf("proto: GetGatesResponse: wiretype end group for non-group")
 12884  		}
 12885  		if fieldNum <= 0 {
 12886  			return fmt.Errorf("proto: GetGatesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12887  		}
 12888  		switch fieldNum {
 12889  		case 1:
 12890  			if wireType != 2 {
 12891  				return fmt.Errorf("proto: wrong wireType = %d for field Gates", wireType)
 12892  			}
 12893  			var msglen int
 12894  			for shift := uint(0); ; shift += 7 {
 12895  				if shift >= 64 {
 12896  					return ErrIntOverflow
 12897  				}
 12898  				if iNdEx >= l {
 12899  					return io.ErrUnexpectedEOF
 12900  				}
 12901  				b := dAtA[iNdEx]
 12902  				iNdEx++
 12903  				msglen |= int(b&0x7F) << shift
 12904  				if b < 0x80 {
 12905  					break
 12906  				}
 12907  			}
 12908  			if msglen < 0 {
 12909  				return ErrInvalidLength
 12910  			}
 12911  			postIndex := iNdEx + msglen
 12912  			if postIndex < 0 {
 12913  				return ErrInvalidLength
 12914  			}
 12915  			if postIndex > l {
 12916  				return io.ErrUnexpectedEOF
 12917  			}
 12918  			m.Gates = append(m.Gates, &VTGate{})
 12919  			if err := m.Gates[len(m.Gates)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12920  				return err
 12921  			}
 12922  			iNdEx = postIndex
 12923  		default:
 12924  			iNdEx = preIndex
 12925  			skippy, err := skip(dAtA[iNdEx:])
 12926  			if err != nil {
 12927  				return err
 12928  			}
 12929  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12930  				return ErrInvalidLength
 12931  			}
 12932  			if (iNdEx + skippy) > l {
 12933  				return io.ErrUnexpectedEOF
 12934  			}
 12935  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12936  			iNdEx += skippy
 12937  		}
 12938  	}
 12939  
 12940  	if iNdEx > l {
 12941  		return io.ErrUnexpectedEOF
 12942  	}
 12943  	return nil
 12944  }
 12945  func (m *GetKeyspaceRequest) UnmarshalVT(dAtA []byte) error {
 12946  	l := len(dAtA)
 12947  	iNdEx := 0
 12948  	for iNdEx < l {
 12949  		preIndex := iNdEx
 12950  		var wire uint64
 12951  		for shift := uint(0); ; shift += 7 {
 12952  			if shift >= 64 {
 12953  				return ErrIntOverflow
 12954  			}
 12955  			if iNdEx >= l {
 12956  				return io.ErrUnexpectedEOF
 12957  			}
 12958  			b := dAtA[iNdEx]
 12959  			iNdEx++
 12960  			wire |= uint64(b&0x7F) << shift
 12961  			if b < 0x80 {
 12962  				break
 12963  			}
 12964  		}
 12965  		fieldNum := int32(wire >> 3)
 12966  		wireType := int(wire & 0x7)
 12967  		if wireType == 4 {
 12968  			return fmt.Errorf("proto: GetKeyspaceRequest: wiretype end group for non-group")
 12969  		}
 12970  		if fieldNum <= 0 {
 12971  			return fmt.Errorf("proto: GetKeyspaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12972  		}
 12973  		switch fieldNum {
 12974  		case 1:
 12975  			if wireType != 2 {
 12976  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 12977  			}
 12978  			var stringLen uint64
 12979  			for shift := uint(0); ; shift += 7 {
 12980  				if shift >= 64 {
 12981  					return ErrIntOverflow
 12982  				}
 12983  				if iNdEx >= l {
 12984  					return io.ErrUnexpectedEOF
 12985  				}
 12986  				b := dAtA[iNdEx]
 12987  				iNdEx++
 12988  				stringLen |= uint64(b&0x7F) << shift
 12989  				if b < 0x80 {
 12990  					break
 12991  				}
 12992  			}
 12993  			intStringLen := int(stringLen)
 12994  			if intStringLen < 0 {
 12995  				return ErrInvalidLength
 12996  			}
 12997  			postIndex := iNdEx + intStringLen
 12998  			if postIndex < 0 {
 12999  				return ErrInvalidLength
 13000  			}
 13001  			if postIndex > l {
 13002  				return io.ErrUnexpectedEOF
 13003  			}
 13004  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 13005  			iNdEx = postIndex
 13006  		case 2:
 13007  			if wireType != 2 {
 13008  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 13009  			}
 13010  			var stringLen uint64
 13011  			for shift := uint(0); ; shift += 7 {
 13012  				if shift >= 64 {
 13013  					return ErrIntOverflow
 13014  				}
 13015  				if iNdEx >= l {
 13016  					return io.ErrUnexpectedEOF
 13017  				}
 13018  				b := dAtA[iNdEx]
 13019  				iNdEx++
 13020  				stringLen |= uint64(b&0x7F) << shift
 13021  				if b < 0x80 {
 13022  					break
 13023  				}
 13024  			}
 13025  			intStringLen := int(stringLen)
 13026  			if intStringLen < 0 {
 13027  				return ErrInvalidLength
 13028  			}
 13029  			postIndex := iNdEx + intStringLen
 13030  			if postIndex < 0 {
 13031  				return ErrInvalidLength
 13032  			}
 13033  			if postIndex > l {
 13034  				return io.ErrUnexpectedEOF
 13035  			}
 13036  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 13037  			iNdEx = postIndex
 13038  		default:
 13039  			iNdEx = preIndex
 13040  			skippy, err := skip(dAtA[iNdEx:])
 13041  			if err != nil {
 13042  				return err
 13043  			}
 13044  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13045  				return ErrInvalidLength
 13046  			}
 13047  			if (iNdEx + skippy) > l {
 13048  				return io.ErrUnexpectedEOF
 13049  			}
 13050  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13051  			iNdEx += skippy
 13052  		}
 13053  	}
 13054  
 13055  	if iNdEx > l {
 13056  		return io.ErrUnexpectedEOF
 13057  	}
 13058  	return nil
 13059  }
 13060  func (m *GetKeyspacesRequest) UnmarshalVT(dAtA []byte) error {
 13061  	l := len(dAtA)
 13062  	iNdEx := 0
 13063  	for iNdEx < l {
 13064  		preIndex := iNdEx
 13065  		var wire uint64
 13066  		for shift := uint(0); ; shift += 7 {
 13067  			if shift >= 64 {
 13068  				return ErrIntOverflow
 13069  			}
 13070  			if iNdEx >= l {
 13071  				return io.ErrUnexpectedEOF
 13072  			}
 13073  			b := dAtA[iNdEx]
 13074  			iNdEx++
 13075  			wire |= uint64(b&0x7F) << shift
 13076  			if b < 0x80 {
 13077  				break
 13078  			}
 13079  		}
 13080  		fieldNum := int32(wire >> 3)
 13081  		wireType := int(wire & 0x7)
 13082  		if wireType == 4 {
 13083  			return fmt.Errorf("proto: GetKeyspacesRequest: wiretype end group for non-group")
 13084  		}
 13085  		if fieldNum <= 0 {
 13086  			return fmt.Errorf("proto: GetKeyspacesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13087  		}
 13088  		switch fieldNum {
 13089  		case 1:
 13090  			if wireType != 2 {
 13091  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 13092  			}
 13093  			var stringLen uint64
 13094  			for shift := uint(0); ; shift += 7 {
 13095  				if shift >= 64 {
 13096  					return ErrIntOverflow
 13097  				}
 13098  				if iNdEx >= l {
 13099  					return io.ErrUnexpectedEOF
 13100  				}
 13101  				b := dAtA[iNdEx]
 13102  				iNdEx++
 13103  				stringLen |= uint64(b&0x7F) << shift
 13104  				if b < 0x80 {
 13105  					break
 13106  				}
 13107  			}
 13108  			intStringLen := int(stringLen)
 13109  			if intStringLen < 0 {
 13110  				return ErrInvalidLength
 13111  			}
 13112  			postIndex := iNdEx + intStringLen
 13113  			if postIndex < 0 {
 13114  				return ErrInvalidLength
 13115  			}
 13116  			if postIndex > l {
 13117  				return io.ErrUnexpectedEOF
 13118  			}
 13119  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 13120  			iNdEx = postIndex
 13121  		default:
 13122  			iNdEx = preIndex
 13123  			skippy, err := skip(dAtA[iNdEx:])
 13124  			if err != nil {
 13125  				return err
 13126  			}
 13127  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13128  				return ErrInvalidLength
 13129  			}
 13130  			if (iNdEx + skippy) > l {
 13131  				return io.ErrUnexpectedEOF
 13132  			}
 13133  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13134  			iNdEx += skippy
 13135  		}
 13136  	}
 13137  
 13138  	if iNdEx > l {
 13139  		return io.ErrUnexpectedEOF
 13140  	}
 13141  	return nil
 13142  }
 13143  func (m *GetKeyspacesResponse) UnmarshalVT(dAtA []byte) error {
 13144  	l := len(dAtA)
 13145  	iNdEx := 0
 13146  	for iNdEx < l {
 13147  		preIndex := iNdEx
 13148  		var wire uint64
 13149  		for shift := uint(0); ; shift += 7 {
 13150  			if shift >= 64 {
 13151  				return ErrIntOverflow
 13152  			}
 13153  			if iNdEx >= l {
 13154  				return io.ErrUnexpectedEOF
 13155  			}
 13156  			b := dAtA[iNdEx]
 13157  			iNdEx++
 13158  			wire |= uint64(b&0x7F) << shift
 13159  			if b < 0x80 {
 13160  				break
 13161  			}
 13162  		}
 13163  		fieldNum := int32(wire >> 3)
 13164  		wireType := int(wire & 0x7)
 13165  		if wireType == 4 {
 13166  			return fmt.Errorf("proto: GetKeyspacesResponse: wiretype end group for non-group")
 13167  		}
 13168  		if fieldNum <= 0 {
 13169  			return fmt.Errorf("proto: GetKeyspacesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13170  		}
 13171  		switch fieldNum {
 13172  		case 1:
 13173  			if wireType != 2 {
 13174  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspaces", wireType)
 13175  			}
 13176  			var msglen int
 13177  			for shift := uint(0); ; shift += 7 {
 13178  				if shift >= 64 {
 13179  					return ErrIntOverflow
 13180  				}
 13181  				if iNdEx >= l {
 13182  					return io.ErrUnexpectedEOF
 13183  				}
 13184  				b := dAtA[iNdEx]
 13185  				iNdEx++
 13186  				msglen |= int(b&0x7F) << shift
 13187  				if b < 0x80 {
 13188  					break
 13189  				}
 13190  			}
 13191  			if msglen < 0 {
 13192  				return ErrInvalidLength
 13193  			}
 13194  			postIndex := iNdEx + msglen
 13195  			if postIndex < 0 {
 13196  				return ErrInvalidLength
 13197  			}
 13198  			if postIndex > l {
 13199  				return io.ErrUnexpectedEOF
 13200  			}
 13201  			m.Keyspaces = append(m.Keyspaces, &Keyspace{})
 13202  			if err := m.Keyspaces[len(m.Keyspaces)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13203  				return err
 13204  			}
 13205  			iNdEx = postIndex
 13206  		default:
 13207  			iNdEx = preIndex
 13208  			skippy, err := skip(dAtA[iNdEx:])
 13209  			if err != nil {
 13210  				return err
 13211  			}
 13212  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13213  				return ErrInvalidLength
 13214  			}
 13215  			if (iNdEx + skippy) > l {
 13216  				return io.ErrUnexpectedEOF
 13217  			}
 13218  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13219  			iNdEx += skippy
 13220  		}
 13221  	}
 13222  
 13223  	if iNdEx > l {
 13224  		return io.ErrUnexpectedEOF
 13225  	}
 13226  	return nil
 13227  }
 13228  func (m *GetSchemaRequest) UnmarshalVT(dAtA []byte) error {
 13229  	l := len(dAtA)
 13230  	iNdEx := 0
 13231  	for iNdEx < l {
 13232  		preIndex := iNdEx
 13233  		var wire uint64
 13234  		for shift := uint(0); ; shift += 7 {
 13235  			if shift >= 64 {
 13236  				return ErrIntOverflow
 13237  			}
 13238  			if iNdEx >= l {
 13239  				return io.ErrUnexpectedEOF
 13240  			}
 13241  			b := dAtA[iNdEx]
 13242  			iNdEx++
 13243  			wire |= uint64(b&0x7F) << shift
 13244  			if b < 0x80 {
 13245  				break
 13246  			}
 13247  		}
 13248  		fieldNum := int32(wire >> 3)
 13249  		wireType := int(wire & 0x7)
 13250  		if wireType == 4 {
 13251  			return fmt.Errorf("proto: GetSchemaRequest: wiretype end group for non-group")
 13252  		}
 13253  		if fieldNum <= 0 {
 13254  			return fmt.Errorf("proto: GetSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13255  		}
 13256  		switch fieldNum {
 13257  		case 1:
 13258  			if wireType != 2 {
 13259  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 13260  			}
 13261  			var stringLen uint64
 13262  			for shift := uint(0); ; shift += 7 {
 13263  				if shift >= 64 {
 13264  					return ErrIntOverflow
 13265  				}
 13266  				if iNdEx >= l {
 13267  					return io.ErrUnexpectedEOF
 13268  				}
 13269  				b := dAtA[iNdEx]
 13270  				iNdEx++
 13271  				stringLen |= uint64(b&0x7F) << shift
 13272  				if b < 0x80 {
 13273  					break
 13274  				}
 13275  			}
 13276  			intStringLen := int(stringLen)
 13277  			if intStringLen < 0 {
 13278  				return ErrInvalidLength
 13279  			}
 13280  			postIndex := iNdEx + intStringLen
 13281  			if postIndex < 0 {
 13282  				return ErrInvalidLength
 13283  			}
 13284  			if postIndex > l {
 13285  				return io.ErrUnexpectedEOF
 13286  			}
 13287  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 13288  			iNdEx = postIndex
 13289  		case 2:
 13290  			if wireType != 2 {
 13291  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 13292  			}
 13293  			var stringLen uint64
 13294  			for shift := uint(0); ; shift += 7 {
 13295  				if shift >= 64 {
 13296  					return ErrIntOverflow
 13297  				}
 13298  				if iNdEx >= l {
 13299  					return io.ErrUnexpectedEOF
 13300  				}
 13301  				b := dAtA[iNdEx]
 13302  				iNdEx++
 13303  				stringLen |= uint64(b&0x7F) << shift
 13304  				if b < 0x80 {
 13305  					break
 13306  				}
 13307  			}
 13308  			intStringLen := int(stringLen)
 13309  			if intStringLen < 0 {
 13310  				return ErrInvalidLength
 13311  			}
 13312  			postIndex := iNdEx + intStringLen
 13313  			if postIndex < 0 {
 13314  				return ErrInvalidLength
 13315  			}
 13316  			if postIndex > l {
 13317  				return io.ErrUnexpectedEOF
 13318  			}
 13319  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 13320  			iNdEx = postIndex
 13321  		case 3:
 13322  			if wireType != 2 {
 13323  				return fmt.Errorf("proto: wrong wireType = %d for field Table", 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.Table = string(dAtA[iNdEx:postIndex])
 13352  			iNdEx = postIndex
 13353  		case 4:
 13354  			if wireType != 2 {
 13355  				return fmt.Errorf("proto: wrong wireType = %d for field TableSizeOptions", wireType)
 13356  			}
 13357  			var msglen int
 13358  			for shift := uint(0); ; shift += 7 {
 13359  				if shift >= 64 {
 13360  					return ErrIntOverflow
 13361  				}
 13362  				if iNdEx >= l {
 13363  					return io.ErrUnexpectedEOF
 13364  				}
 13365  				b := dAtA[iNdEx]
 13366  				iNdEx++
 13367  				msglen |= int(b&0x7F) << shift
 13368  				if b < 0x80 {
 13369  					break
 13370  				}
 13371  			}
 13372  			if msglen < 0 {
 13373  				return ErrInvalidLength
 13374  			}
 13375  			postIndex := iNdEx + msglen
 13376  			if postIndex < 0 {
 13377  				return ErrInvalidLength
 13378  			}
 13379  			if postIndex > l {
 13380  				return io.ErrUnexpectedEOF
 13381  			}
 13382  			if m.TableSizeOptions == nil {
 13383  				m.TableSizeOptions = &GetSchemaTableSizeOptions{}
 13384  			}
 13385  			if err := m.TableSizeOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13386  				return err
 13387  			}
 13388  			iNdEx = postIndex
 13389  		default:
 13390  			iNdEx = preIndex
 13391  			skippy, err := skip(dAtA[iNdEx:])
 13392  			if err != nil {
 13393  				return err
 13394  			}
 13395  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13396  				return ErrInvalidLength
 13397  			}
 13398  			if (iNdEx + skippy) > l {
 13399  				return io.ErrUnexpectedEOF
 13400  			}
 13401  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13402  			iNdEx += skippy
 13403  		}
 13404  	}
 13405  
 13406  	if iNdEx > l {
 13407  		return io.ErrUnexpectedEOF
 13408  	}
 13409  	return nil
 13410  }
 13411  func (m *GetSchemasRequest) UnmarshalVT(dAtA []byte) error {
 13412  	l := len(dAtA)
 13413  	iNdEx := 0
 13414  	for iNdEx < l {
 13415  		preIndex := iNdEx
 13416  		var wire uint64
 13417  		for shift := uint(0); ; shift += 7 {
 13418  			if shift >= 64 {
 13419  				return ErrIntOverflow
 13420  			}
 13421  			if iNdEx >= l {
 13422  				return io.ErrUnexpectedEOF
 13423  			}
 13424  			b := dAtA[iNdEx]
 13425  			iNdEx++
 13426  			wire |= uint64(b&0x7F) << shift
 13427  			if b < 0x80 {
 13428  				break
 13429  			}
 13430  		}
 13431  		fieldNum := int32(wire >> 3)
 13432  		wireType := int(wire & 0x7)
 13433  		if wireType == 4 {
 13434  			return fmt.Errorf("proto: GetSchemasRequest: wiretype end group for non-group")
 13435  		}
 13436  		if fieldNum <= 0 {
 13437  			return fmt.Errorf("proto: GetSchemasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13438  		}
 13439  		switch fieldNum {
 13440  		case 1:
 13441  			if wireType != 2 {
 13442  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 13443  			}
 13444  			var stringLen uint64
 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  				stringLen |= uint64(b&0x7F) << shift
 13455  				if b < 0x80 {
 13456  					break
 13457  				}
 13458  			}
 13459  			intStringLen := int(stringLen)
 13460  			if intStringLen < 0 {
 13461  				return ErrInvalidLength
 13462  			}
 13463  			postIndex := iNdEx + intStringLen
 13464  			if postIndex < 0 {
 13465  				return ErrInvalidLength
 13466  			}
 13467  			if postIndex > l {
 13468  				return io.ErrUnexpectedEOF
 13469  			}
 13470  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 13471  			iNdEx = postIndex
 13472  		case 2:
 13473  			if wireType != 2 {
 13474  				return fmt.Errorf("proto: wrong wireType = %d for field TableSizeOptions", wireType)
 13475  			}
 13476  			var msglen int
 13477  			for shift := uint(0); ; shift += 7 {
 13478  				if shift >= 64 {
 13479  					return ErrIntOverflow
 13480  				}
 13481  				if iNdEx >= l {
 13482  					return io.ErrUnexpectedEOF
 13483  				}
 13484  				b := dAtA[iNdEx]
 13485  				iNdEx++
 13486  				msglen |= int(b&0x7F) << shift
 13487  				if b < 0x80 {
 13488  					break
 13489  				}
 13490  			}
 13491  			if msglen < 0 {
 13492  				return ErrInvalidLength
 13493  			}
 13494  			postIndex := iNdEx + msglen
 13495  			if postIndex < 0 {
 13496  				return ErrInvalidLength
 13497  			}
 13498  			if postIndex > l {
 13499  				return io.ErrUnexpectedEOF
 13500  			}
 13501  			if m.TableSizeOptions == nil {
 13502  				m.TableSizeOptions = &GetSchemaTableSizeOptions{}
 13503  			}
 13504  			if err := m.TableSizeOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13505  				return err
 13506  			}
 13507  			iNdEx = postIndex
 13508  		default:
 13509  			iNdEx = preIndex
 13510  			skippy, err := skip(dAtA[iNdEx:])
 13511  			if err != nil {
 13512  				return err
 13513  			}
 13514  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13515  				return ErrInvalidLength
 13516  			}
 13517  			if (iNdEx + skippy) > l {
 13518  				return io.ErrUnexpectedEOF
 13519  			}
 13520  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13521  			iNdEx += skippy
 13522  		}
 13523  	}
 13524  
 13525  	if iNdEx > l {
 13526  		return io.ErrUnexpectedEOF
 13527  	}
 13528  	return nil
 13529  }
 13530  func (m *GetSchemasResponse) UnmarshalVT(dAtA []byte) error {
 13531  	l := len(dAtA)
 13532  	iNdEx := 0
 13533  	for iNdEx < l {
 13534  		preIndex := iNdEx
 13535  		var wire uint64
 13536  		for shift := uint(0); ; shift += 7 {
 13537  			if shift >= 64 {
 13538  				return ErrIntOverflow
 13539  			}
 13540  			if iNdEx >= l {
 13541  				return io.ErrUnexpectedEOF
 13542  			}
 13543  			b := dAtA[iNdEx]
 13544  			iNdEx++
 13545  			wire |= uint64(b&0x7F) << shift
 13546  			if b < 0x80 {
 13547  				break
 13548  			}
 13549  		}
 13550  		fieldNum := int32(wire >> 3)
 13551  		wireType := int(wire & 0x7)
 13552  		if wireType == 4 {
 13553  			return fmt.Errorf("proto: GetSchemasResponse: wiretype end group for non-group")
 13554  		}
 13555  		if fieldNum <= 0 {
 13556  			return fmt.Errorf("proto: GetSchemasResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13557  		}
 13558  		switch fieldNum {
 13559  		case 1:
 13560  			if wireType != 2 {
 13561  				return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType)
 13562  			}
 13563  			var msglen int
 13564  			for shift := uint(0); ; shift += 7 {
 13565  				if shift >= 64 {
 13566  					return ErrIntOverflow
 13567  				}
 13568  				if iNdEx >= l {
 13569  					return io.ErrUnexpectedEOF
 13570  				}
 13571  				b := dAtA[iNdEx]
 13572  				iNdEx++
 13573  				msglen |= int(b&0x7F) << shift
 13574  				if b < 0x80 {
 13575  					break
 13576  				}
 13577  			}
 13578  			if msglen < 0 {
 13579  				return ErrInvalidLength
 13580  			}
 13581  			postIndex := iNdEx + msglen
 13582  			if postIndex < 0 {
 13583  				return ErrInvalidLength
 13584  			}
 13585  			if postIndex > l {
 13586  				return io.ErrUnexpectedEOF
 13587  			}
 13588  			m.Schemas = append(m.Schemas, &Schema{})
 13589  			if err := m.Schemas[len(m.Schemas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13590  				return err
 13591  			}
 13592  			iNdEx = postIndex
 13593  		default:
 13594  			iNdEx = preIndex
 13595  			skippy, err := skip(dAtA[iNdEx:])
 13596  			if err != nil {
 13597  				return err
 13598  			}
 13599  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13600  				return ErrInvalidLength
 13601  			}
 13602  			if (iNdEx + skippy) > l {
 13603  				return io.ErrUnexpectedEOF
 13604  			}
 13605  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13606  			iNdEx += skippy
 13607  		}
 13608  	}
 13609  
 13610  	if iNdEx > l {
 13611  		return io.ErrUnexpectedEOF
 13612  	}
 13613  	return nil
 13614  }
 13615  func (m *GetShardReplicationPositionsRequest) UnmarshalVT(dAtA []byte) error {
 13616  	l := len(dAtA)
 13617  	iNdEx := 0
 13618  	for iNdEx < l {
 13619  		preIndex := iNdEx
 13620  		var wire uint64
 13621  		for shift := uint(0); ; shift += 7 {
 13622  			if shift >= 64 {
 13623  				return ErrIntOverflow
 13624  			}
 13625  			if iNdEx >= l {
 13626  				return io.ErrUnexpectedEOF
 13627  			}
 13628  			b := dAtA[iNdEx]
 13629  			iNdEx++
 13630  			wire |= uint64(b&0x7F) << shift
 13631  			if b < 0x80 {
 13632  				break
 13633  			}
 13634  		}
 13635  		fieldNum := int32(wire >> 3)
 13636  		wireType := int(wire & 0x7)
 13637  		if wireType == 4 {
 13638  			return fmt.Errorf("proto: GetShardReplicationPositionsRequest: wiretype end group for non-group")
 13639  		}
 13640  		if fieldNum <= 0 {
 13641  			return fmt.Errorf("proto: GetShardReplicationPositionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13642  		}
 13643  		switch fieldNum {
 13644  		case 1:
 13645  			if wireType != 2 {
 13646  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 13647  			}
 13648  			var stringLen uint64
 13649  			for shift := uint(0); ; shift += 7 {
 13650  				if shift >= 64 {
 13651  					return ErrIntOverflow
 13652  				}
 13653  				if iNdEx >= l {
 13654  					return io.ErrUnexpectedEOF
 13655  				}
 13656  				b := dAtA[iNdEx]
 13657  				iNdEx++
 13658  				stringLen |= uint64(b&0x7F) << shift
 13659  				if b < 0x80 {
 13660  					break
 13661  				}
 13662  			}
 13663  			intStringLen := int(stringLen)
 13664  			if intStringLen < 0 {
 13665  				return ErrInvalidLength
 13666  			}
 13667  			postIndex := iNdEx + intStringLen
 13668  			if postIndex < 0 {
 13669  				return ErrInvalidLength
 13670  			}
 13671  			if postIndex > l {
 13672  				return io.ErrUnexpectedEOF
 13673  			}
 13674  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 13675  			iNdEx = postIndex
 13676  		case 2:
 13677  			if wireType != 2 {
 13678  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspaces", wireType)
 13679  			}
 13680  			var stringLen uint64
 13681  			for shift := uint(0); ; shift += 7 {
 13682  				if shift >= 64 {
 13683  					return ErrIntOverflow
 13684  				}
 13685  				if iNdEx >= l {
 13686  					return io.ErrUnexpectedEOF
 13687  				}
 13688  				b := dAtA[iNdEx]
 13689  				iNdEx++
 13690  				stringLen |= uint64(b&0x7F) << shift
 13691  				if b < 0x80 {
 13692  					break
 13693  				}
 13694  			}
 13695  			intStringLen := int(stringLen)
 13696  			if intStringLen < 0 {
 13697  				return ErrInvalidLength
 13698  			}
 13699  			postIndex := iNdEx + intStringLen
 13700  			if postIndex < 0 {
 13701  				return ErrInvalidLength
 13702  			}
 13703  			if postIndex > l {
 13704  				return io.ErrUnexpectedEOF
 13705  			}
 13706  			m.Keyspaces = append(m.Keyspaces, string(dAtA[iNdEx:postIndex]))
 13707  			iNdEx = postIndex
 13708  		case 3:
 13709  			if wireType != 2 {
 13710  				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceShards", wireType)
 13711  			}
 13712  			var stringLen uint64
 13713  			for shift := uint(0); ; shift += 7 {
 13714  				if shift >= 64 {
 13715  					return ErrIntOverflow
 13716  				}
 13717  				if iNdEx >= l {
 13718  					return io.ErrUnexpectedEOF
 13719  				}
 13720  				b := dAtA[iNdEx]
 13721  				iNdEx++
 13722  				stringLen |= uint64(b&0x7F) << shift
 13723  				if b < 0x80 {
 13724  					break
 13725  				}
 13726  			}
 13727  			intStringLen := int(stringLen)
 13728  			if intStringLen < 0 {
 13729  				return ErrInvalidLength
 13730  			}
 13731  			postIndex := iNdEx + intStringLen
 13732  			if postIndex < 0 {
 13733  				return ErrInvalidLength
 13734  			}
 13735  			if postIndex > l {
 13736  				return io.ErrUnexpectedEOF
 13737  			}
 13738  			m.KeyspaceShards = append(m.KeyspaceShards, string(dAtA[iNdEx:postIndex]))
 13739  			iNdEx = postIndex
 13740  		default:
 13741  			iNdEx = preIndex
 13742  			skippy, err := skip(dAtA[iNdEx:])
 13743  			if err != nil {
 13744  				return err
 13745  			}
 13746  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13747  				return ErrInvalidLength
 13748  			}
 13749  			if (iNdEx + skippy) > l {
 13750  				return io.ErrUnexpectedEOF
 13751  			}
 13752  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13753  			iNdEx += skippy
 13754  		}
 13755  	}
 13756  
 13757  	if iNdEx > l {
 13758  		return io.ErrUnexpectedEOF
 13759  	}
 13760  	return nil
 13761  }
 13762  func (m *GetShardReplicationPositionsResponse) UnmarshalVT(dAtA []byte) error {
 13763  	l := len(dAtA)
 13764  	iNdEx := 0
 13765  	for iNdEx < l {
 13766  		preIndex := iNdEx
 13767  		var wire uint64
 13768  		for shift := uint(0); ; shift += 7 {
 13769  			if shift >= 64 {
 13770  				return ErrIntOverflow
 13771  			}
 13772  			if iNdEx >= l {
 13773  				return io.ErrUnexpectedEOF
 13774  			}
 13775  			b := dAtA[iNdEx]
 13776  			iNdEx++
 13777  			wire |= uint64(b&0x7F) << shift
 13778  			if b < 0x80 {
 13779  				break
 13780  			}
 13781  		}
 13782  		fieldNum := int32(wire >> 3)
 13783  		wireType := int(wire & 0x7)
 13784  		if wireType == 4 {
 13785  			return fmt.Errorf("proto: GetShardReplicationPositionsResponse: wiretype end group for non-group")
 13786  		}
 13787  		if fieldNum <= 0 {
 13788  			return fmt.Errorf("proto: GetShardReplicationPositionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13789  		}
 13790  		switch fieldNum {
 13791  		case 1:
 13792  			if wireType != 2 {
 13793  				return fmt.Errorf("proto: wrong wireType = %d for field ReplicationPositions", wireType)
 13794  			}
 13795  			var msglen int
 13796  			for shift := uint(0); ; shift += 7 {
 13797  				if shift >= 64 {
 13798  					return ErrIntOverflow
 13799  				}
 13800  				if iNdEx >= l {
 13801  					return io.ErrUnexpectedEOF
 13802  				}
 13803  				b := dAtA[iNdEx]
 13804  				iNdEx++
 13805  				msglen |= int(b&0x7F) << shift
 13806  				if b < 0x80 {
 13807  					break
 13808  				}
 13809  			}
 13810  			if msglen < 0 {
 13811  				return ErrInvalidLength
 13812  			}
 13813  			postIndex := iNdEx + msglen
 13814  			if postIndex < 0 {
 13815  				return ErrInvalidLength
 13816  			}
 13817  			if postIndex > l {
 13818  				return io.ErrUnexpectedEOF
 13819  			}
 13820  			m.ReplicationPositions = append(m.ReplicationPositions, &ClusterShardReplicationPosition{})
 13821  			if err := m.ReplicationPositions[len(m.ReplicationPositions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13822  				return err
 13823  			}
 13824  			iNdEx = postIndex
 13825  		default:
 13826  			iNdEx = preIndex
 13827  			skippy, err := skip(dAtA[iNdEx:])
 13828  			if err != nil {
 13829  				return err
 13830  			}
 13831  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13832  				return ErrInvalidLength
 13833  			}
 13834  			if (iNdEx + skippy) > l {
 13835  				return io.ErrUnexpectedEOF
 13836  			}
 13837  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13838  			iNdEx += skippy
 13839  		}
 13840  	}
 13841  
 13842  	if iNdEx > l {
 13843  		return io.ErrUnexpectedEOF
 13844  	}
 13845  	return nil
 13846  }
 13847  func (m *GetSrvVSchemaRequest) UnmarshalVT(dAtA []byte) error {
 13848  	l := len(dAtA)
 13849  	iNdEx := 0
 13850  	for iNdEx < l {
 13851  		preIndex := iNdEx
 13852  		var wire uint64
 13853  		for shift := uint(0); ; shift += 7 {
 13854  			if shift >= 64 {
 13855  				return ErrIntOverflow
 13856  			}
 13857  			if iNdEx >= l {
 13858  				return io.ErrUnexpectedEOF
 13859  			}
 13860  			b := dAtA[iNdEx]
 13861  			iNdEx++
 13862  			wire |= uint64(b&0x7F) << shift
 13863  			if b < 0x80 {
 13864  				break
 13865  			}
 13866  		}
 13867  		fieldNum := int32(wire >> 3)
 13868  		wireType := int(wire & 0x7)
 13869  		if wireType == 4 {
 13870  			return fmt.Errorf("proto: GetSrvVSchemaRequest: wiretype end group for non-group")
 13871  		}
 13872  		if fieldNum <= 0 {
 13873  			return fmt.Errorf("proto: GetSrvVSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13874  		}
 13875  		switch fieldNum {
 13876  		case 1:
 13877  			if wireType != 2 {
 13878  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 13879  			}
 13880  			var stringLen uint64
 13881  			for shift := uint(0); ; shift += 7 {
 13882  				if shift >= 64 {
 13883  					return ErrIntOverflow
 13884  				}
 13885  				if iNdEx >= l {
 13886  					return io.ErrUnexpectedEOF
 13887  				}
 13888  				b := dAtA[iNdEx]
 13889  				iNdEx++
 13890  				stringLen |= uint64(b&0x7F) << shift
 13891  				if b < 0x80 {
 13892  					break
 13893  				}
 13894  			}
 13895  			intStringLen := int(stringLen)
 13896  			if intStringLen < 0 {
 13897  				return ErrInvalidLength
 13898  			}
 13899  			postIndex := iNdEx + intStringLen
 13900  			if postIndex < 0 {
 13901  				return ErrInvalidLength
 13902  			}
 13903  			if postIndex > l {
 13904  				return io.ErrUnexpectedEOF
 13905  			}
 13906  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 13907  			iNdEx = postIndex
 13908  		case 2:
 13909  			if wireType != 2 {
 13910  				return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType)
 13911  			}
 13912  			var stringLen uint64
 13913  			for shift := uint(0); ; shift += 7 {
 13914  				if shift >= 64 {
 13915  					return ErrIntOverflow
 13916  				}
 13917  				if iNdEx >= l {
 13918  					return io.ErrUnexpectedEOF
 13919  				}
 13920  				b := dAtA[iNdEx]
 13921  				iNdEx++
 13922  				stringLen |= uint64(b&0x7F) << shift
 13923  				if b < 0x80 {
 13924  					break
 13925  				}
 13926  			}
 13927  			intStringLen := int(stringLen)
 13928  			if intStringLen < 0 {
 13929  				return ErrInvalidLength
 13930  			}
 13931  			postIndex := iNdEx + intStringLen
 13932  			if postIndex < 0 {
 13933  				return ErrInvalidLength
 13934  			}
 13935  			if postIndex > l {
 13936  				return io.ErrUnexpectedEOF
 13937  			}
 13938  			m.Cell = string(dAtA[iNdEx:postIndex])
 13939  			iNdEx = postIndex
 13940  		default:
 13941  			iNdEx = preIndex
 13942  			skippy, err := skip(dAtA[iNdEx:])
 13943  			if err != nil {
 13944  				return err
 13945  			}
 13946  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13947  				return ErrInvalidLength
 13948  			}
 13949  			if (iNdEx + skippy) > l {
 13950  				return io.ErrUnexpectedEOF
 13951  			}
 13952  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13953  			iNdEx += skippy
 13954  		}
 13955  	}
 13956  
 13957  	if iNdEx > l {
 13958  		return io.ErrUnexpectedEOF
 13959  	}
 13960  	return nil
 13961  }
 13962  func (m *GetSrvVSchemasRequest) UnmarshalVT(dAtA []byte) error {
 13963  	l := len(dAtA)
 13964  	iNdEx := 0
 13965  	for iNdEx < l {
 13966  		preIndex := iNdEx
 13967  		var wire uint64
 13968  		for shift := uint(0); ; shift += 7 {
 13969  			if shift >= 64 {
 13970  				return ErrIntOverflow
 13971  			}
 13972  			if iNdEx >= l {
 13973  				return io.ErrUnexpectedEOF
 13974  			}
 13975  			b := dAtA[iNdEx]
 13976  			iNdEx++
 13977  			wire |= uint64(b&0x7F) << shift
 13978  			if b < 0x80 {
 13979  				break
 13980  			}
 13981  		}
 13982  		fieldNum := int32(wire >> 3)
 13983  		wireType := int(wire & 0x7)
 13984  		if wireType == 4 {
 13985  			return fmt.Errorf("proto: GetSrvVSchemasRequest: wiretype end group for non-group")
 13986  		}
 13987  		if fieldNum <= 0 {
 13988  			return fmt.Errorf("proto: GetSrvVSchemasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13989  		}
 13990  		switch fieldNum {
 13991  		case 1:
 13992  			if wireType != 2 {
 13993  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 13994  			}
 13995  			var stringLen uint64
 13996  			for shift := uint(0); ; shift += 7 {
 13997  				if shift >= 64 {
 13998  					return ErrIntOverflow
 13999  				}
 14000  				if iNdEx >= l {
 14001  					return io.ErrUnexpectedEOF
 14002  				}
 14003  				b := dAtA[iNdEx]
 14004  				iNdEx++
 14005  				stringLen |= uint64(b&0x7F) << shift
 14006  				if b < 0x80 {
 14007  					break
 14008  				}
 14009  			}
 14010  			intStringLen := int(stringLen)
 14011  			if intStringLen < 0 {
 14012  				return ErrInvalidLength
 14013  			}
 14014  			postIndex := iNdEx + intStringLen
 14015  			if postIndex < 0 {
 14016  				return ErrInvalidLength
 14017  			}
 14018  			if postIndex > l {
 14019  				return io.ErrUnexpectedEOF
 14020  			}
 14021  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 14022  			iNdEx = postIndex
 14023  		case 2:
 14024  			if wireType != 2 {
 14025  				return fmt.Errorf("proto: wrong wireType = %d for field Cells", wireType)
 14026  			}
 14027  			var stringLen uint64
 14028  			for shift := uint(0); ; shift += 7 {
 14029  				if shift >= 64 {
 14030  					return ErrIntOverflow
 14031  				}
 14032  				if iNdEx >= l {
 14033  					return io.ErrUnexpectedEOF
 14034  				}
 14035  				b := dAtA[iNdEx]
 14036  				iNdEx++
 14037  				stringLen |= uint64(b&0x7F) << shift
 14038  				if b < 0x80 {
 14039  					break
 14040  				}
 14041  			}
 14042  			intStringLen := int(stringLen)
 14043  			if intStringLen < 0 {
 14044  				return ErrInvalidLength
 14045  			}
 14046  			postIndex := iNdEx + intStringLen
 14047  			if postIndex < 0 {
 14048  				return ErrInvalidLength
 14049  			}
 14050  			if postIndex > l {
 14051  				return io.ErrUnexpectedEOF
 14052  			}
 14053  			m.Cells = append(m.Cells, string(dAtA[iNdEx:postIndex]))
 14054  			iNdEx = postIndex
 14055  		default:
 14056  			iNdEx = preIndex
 14057  			skippy, err := skip(dAtA[iNdEx:])
 14058  			if err != nil {
 14059  				return err
 14060  			}
 14061  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14062  				return ErrInvalidLength
 14063  			}
 14064  			if (iNdEx + skippy) > l {
 14065  				return io.ErrUnexpectedEOF
 14066  			}
 14067  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14068  			iNdEx += skippy
 14069  		}
 14070  	}
 14071  
 14072  	if iNdEx > l {
 14073  		return io.ErrUnexpectedEOF
 14074  	}
 14075  	return nil
 14076  }
 14077  func (m *GetSrvVSchemasResponse) UnmarshalVT(dAtA []byte) error {
 14078  	l := len(dAtA)
 14079  	iNdEx := 0
 14080  	for iNdEx < l {
 14081  		preIndex := iNdEx
 14082  		var wire uint64
 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  			wire |= uint64(b&0x7F) << shift
 14093  			if b < 0x80 {
 14094  				break
 14095  			}
 14096  		}
 14097  		fieldNum := int32(wire >> 3)
 14098  		wireType := int(wire & 0x7)
 14099  		if wireType == 4 {
 14100  			return fmt.Errorf("proto: GetSrvVSchemasResponse: wiretype end group for non-group")
 14101  		}
 14102  		if fieldNum <= 0 {
 14103  			return fmt.Errorf("proto: GetSrvVSchemasResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14104  		}
 14105  		switch fieldNum {
 14106  		case 1:
 14107  			if wireType != 2 {
 14108  				return fmt.Errorf("proto: wrong wireType = %d for field SrvVSchemas", wireType)
 14109  			}
 14110  			var msglen int
 14111  			for shift := uint(0); ; shift += 7 {
 14112  				if shift >= 64 {
 14113  					return ErrIntOverflow
 14114  				}
 14115  				if iNdEx >= l {
 14116  					return io.ErrUnexpectedEOF
 14117  				}
 14118  				b := dAtA[iNdEx]
 14119  				iNdEx++
 14120  				msglen |= int(b&0x7F) << shift
 14121  				if b < 0x80 {
 14122  					break
 14123  				}
 14124  			}
 14125  			if msglen < 0 {
 14126  				return ErrInvalidLength
 14127  			}
 14128  			postIndex := iNdEx + msglen
 14129  			if postIndex < 0 {
 14130  				return ErrInvalidLength
 14131  			}
 14132  			if postIndex > l {
 14133  				return io.ErrUnexpectedEOF
 14134  			}
 14135  			m.SrvVSchemas = append(m.SrvVSchemas, &SrvVSchema{})
 14136  			if err := m.SrvVSchemas[len(m.SrvVSchemas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14137  				return err
 14138  			}
 14139  			iNdEx = postIndex
 14140  		default:
 14141  			iNdEx = preIndex
 14142  			skippy, err := skip(dAtA[iNdEx:])
 14143  			if err != nil {
 14144  				return err
 14145  			}
 14146  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14147  				return ErrInvalidLength
 14148  			}
 14149  			if (iNdEx + skippy) > l {
 14150  				return io.ErrUnexpectedEOF
 14151  			}
 14152  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14153  			iNdEx += skippy
 14154  		}
 14155  	}
 14156  
 14157  	if iNdEx > l {
 14158  		return io.ErrUnexpectedEOF
 14159  	}
 14160  	return nil
 14161  }
 14162  func (m *GetSchemaTableSizeOptions) UnmarshalVT(dAtA []byte) error {
 14163  	l := len(dAtA)
 14164  	iNdEx := 0
 14165  	for iNdEx < l {
 14166  		preIndex := iNdEx
 14167  		var wire uint64
 14168  		for shift := uint(0); ; shift += 7 {
 14169  			if shift >= 64 {
 14170  				return ErrIntOverflow
 14171  			}
 14172  			if iNdEx >= l {
 14173  				return io.ErrUnexpectedEOF
 14174  			}
 14175  			b := dAtA[iNdEx]
 14176  			iNdEx++
 14177  			wire |= uint64(b&0x7F) << shift
 14178  			if b < 0x80 {
 14179  				break
 14180  			}
 14181  		}
 14182  		fieldNum := int32(wire >> 3)
 14183  		wireType := int(wire & 0x7)
 14184  		if wireType == 4 {
 14185  			return fmt.Errorf("proto: GetSchemaTableSizeOptions: wiretype end group for non-group")
 14186  		}
 14187  		if fieldNum <= 0 {
 14188  			return fmt.Errorf("proto: GetSchemaTableSizeOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 14189  		}
 14190  		switch fieldNum {
 14191  		case 1:
 14192  			if wireType != 0 {
 14193  				return fmt.Errorf("proto: wrong wireType = %d for field AggregateSizes", wireType)
 14194  			}
 14195  			var v int
 14196  			for shift := uint(0); ; shift += 7 {
 14197  				if shift >= 64 {
 14198  					return ErrIntOverflow
 14199  				}
 14200  				if iNdEx >= l {
 14201  					return io.ErrUnexpectedEOF
 14202  				}
 14203  				b := dAtA[iNdEx]
 14204  				iNdEx++
 14205  				v |= int(b&0x7F) << shift
 14206  				if b < 0x80 {
 14207  					break
 14208  				}
 14209  			}
 14210  			m.AggregateSizes = bool(v != 0)
 14211  		case 2:
 14212  			if wireType != 0 {
 14213  				return fmt.Errorf("proto: wrong wireType = %d for field IncludeNonServingShards", wireType)
 14214  			}
 14215  			var v int
 14216  			for shift := uint(0); ; shift += 7 {
 14217  				if shift >= 64 {
 14218  					return ErrIntOverflow
 14219  				}
 14220  				if iNdEx >= l {
 14221  					return io.ErrUnexpectedEOF
 14222  				}
 14223  				b := dAtA[iNdEx]
 14224  				iNdEx++
 14225  				v |= int(b&0x7F) << shift
 14226  				if b < 0x80 {
 14227  					break
 14228  				}
 14229  			}
 14230  			m.IncludeNonServingShards = bool(v != 0)
 14231  		default:
 14232  			iNdEx = preIndex
 14233  			skippy, err := skip(dAtA[iNdEx:])
 14234  			if err != nil {
 14235  				return err
 14236  			}
 14237  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14238  				return ErrInvalidLength
 14239  			}
 14240  			if (iNdEx + skippy) > l {
 14241  				return io.ErrUnexpectedEOF
 14242  			}
 14243  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14244  			iNdEx += skippy
 14245  		}
 14246  	}
 14247  
 14248  	if iNdEx > l {
 14249  		return io.ErrUnexpectedEOF
 14250  	}
 14251  	return nil
 14252  }
 14253  func (m *GetTabletRequest) UnmarshalVT(dAtA []byte) error {
 14254  	l := len(dAtA)
 14255  	iNdEx := 0
 14256  	for iNdEx < l {
 14257  		preIndex := iNdEx
 14258  		var wire 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  			wire |= uint64(b&0x7F) << shift
 14269  			if b < 0x80 {
 14270  				break
 14271  			}
 14272  		}
 14273  		fieldNum := int32(wire >> 3)
 14274  		wireType := int(wire & 0x7)
 14275  		if wireType == 4 {
 14276  			return fmt.Errorf("proto: GetTabletRequest: wiretype end group for non-group")
 14277  		}
 14278  		if fieldNum <= 0 {
 14279  			return fmt.Errorf("proto: GetTabletRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14280  		}
 14281  		switch fieldNum {
 14282  		case 1:
 14283  			if wireType != 2 {
 14284  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 14285  			}
 14286  			var msglen int
 14287  			for shift := uint(0); ; shift += 7 {
 14288  				if shift >= 64 {
 14289  					return ErrIntOverflow
 14290  				}
 14291  				if iNdEx >= l {
 14292  					return io.ErrUnexpectedEOF
 14293  				}
 14294  				b := dAtA[iNdEx]
 14295  				iNdEx++
 14296  				msglen |= int(b&0x7F) << shift
 14297  				if b < 0x80 {
 14298  					break
 14299  				}
 14300  			}
 14301  			if msglen < 0 {
 14302  				return ErrInvalidLength
 14303  			}
 14304  			postIndex := iNdEx + msglen
 14305  			if postIndex < 0 {
 14306  				return ErrInvalidLength
 14307  			}
 14308  			if postIndex > l {
 14309  				return io.ErrUnexpectedEOF
 14310  			}
 14311  			if m.Alias == nil {
 14312  				m.Alias = &topodata.TabletAlias{}
 14313  			}
 14314  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14315  				return err
 14316  			}
 14317  			iNdEx = postIndex
 14318  		case 2:
 14319  			if wireType != 2 {
 14320  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 14321  			}
 14322  			var stringLen uint64
 14323  			for shift := uint(0); ; shift += 7 {
 14324  				if shift >= 64 {
 14325  					return ErrIntOverflow
 14326  				}
 14327  				if iNdEx >= l {
 14328  					return io.ErrUnexpectedEOF
 14329  				}
 14330  				b := dAtA[iNdEx]
 14331  				iNdEx++
 14332  				stringLen |= uint64(b&0x7F) << shift
 14333  				if b < 0x80 {
 14334  					break
 14335  				}
 14336  			}
 14337  			intStringLen := int(stringLen)
 14338  			if intStringLen < 0 {
 14339  				return ErrInvalidLength
 14340  			}
 14341  			postIndex := iNdEx + intStringLen
 14342  			if postIndex < 0 {
 14343  				return ErrInvalidLength
 14344  			}
 14345  			if postIndex > l {
 14346  				return io.ErrUnexpectedEOF
 14347  			}
 14348  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 14349  			iNdEx = postIndex
 14350  		default:
 14351  			iNdEx = preIndex
 14352  			skippy, err := skip(dAtA[iNdEx:])
 14353  			if err != nil {
 14354  				return err
 14355  			}
 14356  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14357  				return ErrInvalidLength
 14358  			}
 14359  			if (iNdEx + skippy) > l {
 14360  				return io.ErrUnexpectedEOF
 14361  			}
 14362  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14363  			iNdEx += skippy
 14364  		}
 14365  	}
 14366  
 14367  	if iNdEx > l {
 14368  		return io.ErrUnexpectedEOF
 14369  	}
 14370  	return nil
 14371  }
 14372  func (m *GetTabletsRequest) UnmarshalVT(dAtA []byte) error {
 14373  	l := len(dAtA)
 14374  	iNdEx := 0
 14375  	for iNdEx < l {
 14376  		preIndex := iNdEx
 14377  		var wire uint64
 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  			wire |= uint64(b&0x7F) << shift
 14388  			if b < 0x80 {
 14389  				break
 14390  			}
 14391  		}
 14392  		fieldNum := int32(wire >> 3)
 14393  		wireType := int(wire & 0x7)
 14394  		if wireType == 4 {
 14395  			return fmt.Errorf("proto: GetTabletsRequest: wiretype end group for non-group")
 14396  		}
 14397  		if fieldNum <= 0 {
 14398  			return fmt.Errorf("proto: GetTabletsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14399  		}
 14400  		switch fieldNum {
 14401  		case 1:
 14402  			if wireType != 2 {
 14403  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 14404  			}
 14405  			var stringLen uint64
 14406  			for shift := uint(0); ; shift += 7 {
 14407  				if shift >= 64 {
 14408  					return ErrIntOverflow
 14409  				}
 14410  				if iNdEx >= l {
 14411  					return io.ErrUnexpectedEOF
 14412  				}
 14413  				b := dAtA[iNdEx]
 14414  				iNdEx++
 14415  				stringLen |= uint64(b&0x7F) << shift
 14416  				if b < 0x80 {
 14417  					break
 14418  				}
 14419  			}
 14420  			intStringLen := int(stringLen)
 14421  			if intStringLen < 0 {
 14422  				return ErrInvalidLength
 14423  			}
 14424  			postIndex := iNdEx + intStringLen
 14425  			if postIndex < 0 {
 14426  				return ErrInvalidLength
 14427  			}
 14428  			if postIndex > l {
 14429  				return io.ErrUnexpectedEOF
 14430  			}
 14431  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 14432  			iNdEx = postIndex
 14433  		default:
 14434  			iNdEx = preIndex
 14435  			skippy, err := skip(dAtA[iNdEx:])
 14436  			if err != nil {
 14437  				return err
 14438  			}
 14439  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14440  				return ErrInvalidLength
 14441  			}
 14442  			if (iNdEx + skippy) > l {
 14443  				return io.ErrUnexpectedEOF
 14444  			}
 14445  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14446  			iNdEx += skippy
 14447  		}
 14448  	}
 14449  
 14450  	if iNdEx > l {
 14451  		return io.ErrUnexpectedEOF
 14452  	}
 14453  	return nil
 14454  }
 14455  func (m *GetTabletsResponse) UnmarshalVT(dAtA []byte) error {
 14456  	l := len(dAtA)
 14457  	iNdEx := 0
 14458  	for iNdEx < l {
 14459  		preIndex := iNdEx
 14460  		var wire uint64
 14461  		for shift := uint(0); ; shift += 7 {
 14462  			if shift >= 64 {
 14463  				return ErrIntOverflow
 14464  			}
 14465  			if iNdEx >= l {
 14466  				return io.ErrUnexpectedEOF
 14467  			}
 14468  			b := dAtA[iNdEx]
 14469  			iNdEx++
 14470  			wire |= uint64(b&0x7F) << shift
 14471  			if b < 0x80 {
 14472  				break
 14473  			}
 14474  		}
 14475  		fieldNum := int32(wire >> 3)
 14476  		wireType := int(wire & 0x7)
 14477  		if wireType == 4 {
 14478  			return fmt.Errorf("proto: GetTabletsResponse: wiretype end group for non-group")
 14479  		}
 14480  		if fieldNum <= 0 {
 14481  			return fmt.Errorf("proto: GetTabletsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14482  		}
 14483  		switch fieldNum {
 14484  		case 1:
 14485  			if wireType != 2 {
 14486  				return fmt.Errorf("proto: wrong wireType = %d for field Tablets", wireType)
 14487  			}
 14488  			var msglen int
 14489  			for shift := uint(0); ; shift += 7 {
 14490  				if shift >= 64 {
 14491  					return ErrIntOverflow
 14492  				}
 14493  				if iNdEx >= l {
 14494  					return io.ErrUnexpectedEOF
 14495  				}
 14496  				b := dAtA[iNdEx]
 14497  				iNdEx++
 14498  				msglen |= int(b&0x7F) << shift
 14499  				if b < 0x80 {
 14500  					break
 14501  				}
 14502  			}
 14503  			if msglen < 0 {
 14504  				return ErrInvalidLength
 14505  			}
 14506  			postIndex := iNdEx + msglen
 14507  			if postIndex < 0 {
 14508  				return ErrInvalidLength
 14509  			}
 14510  			if postIndex > l {
 14511  				return io.ErrUnexpectedEOF
 14512  			}
 14513  			m.Tablets = append(m.Tablets, &Tablet{})
 14514  			if err := m.Tablets[len(m.Tablets)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14515  				return err
 14516  			}
 14517  			iNdEx = postIndex
 14518  		default:
 14519  			iNdEx = preIndex
 14520  			skippy, err := skip(dAtA[iNdEx:])
 14521  			if err != nil {
 14522  				return err
 14523  			}
 14524  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14525  				return ErrInvalidLength
 14526  			}
 14527  			if (iNdEx + skippy) > l {
 14528  				return io.ErrUnexpectedEOF
 14529  			}
 14530  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14531  			iNdEx += skippy
 14532  		}
 14533  	}
 14534  
 14535  	if iNdEx > l {
 14536  		return io.ErrUnexpectedEOF
 14537  	}
 14538  	return nil
 14539  }
 14540  func (m *GetTopologyPathRequest) UnmarshalVT(dAtA []byte) error {
 14541  	l := len(dAtA)
 14542  	iNdEx := 0
 14543  	for iNdEx < l {
 14544  		preIndex := iNdEx
 14545  		var wire uint64
 14546  		for shift := uint(0); ; shift += 7 {
 14547  			if shift >= 64 {
 14548  				return ErrIntOverflow
 14549  			}
 14550  			if iNdEx >= l {
 14551  				return io.ErrUnexpectedEOF
 14552  			}
 14553  			b := dAtA[iNdEx]
 14554  			iNdEx++
 14555  			wire |= uint64(b&0x7F) << shift
 14556  			if b < 0x80 {
 14557  				break
 14558  			}
 14559  		}
 14560  		fieldNum := int32(wire >> 3)
 14561  		wireType := int(wire & 0x7)
 14562  		if wireType == 4 {
 14563  			return fmt.Errorf("proto: GetTopologyPathRequest: wiretype end group for non-group")
 14564  		}
 14565  		if fieldNum <= 0 {
 14566  			return fmt.Errorf("proto: GetTopologyPathRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14567  		}
 14568  		switch fieldNum {
 14569  		case 1:
 14570  			if wireType != 2 {
 14571  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 14572  			}
 14573  			var stringLen uint64
 14574  			for shift := uint(0); ; shift += 7 {
 14575  				if shift >= 64 {
 14576  					return ErrIntOverflow
 14577  				}
 14578  				if iNdEx >= l {
 14579  					return io.ErrUnexpectedEOF
 14580  				}
 14581  				b := dAtA[iNdEx]
 14582  				iNdEx++
 14583  				stringLen |= uint64(b&0x7F) << shift
 14584  				if b < 0x80 {
 14585  					break
 14586  				}
 14587  			}
 14588  			intStringLen := int(stringLen)
 14589  			if intStringLen < 0 {
 14590  				return ErrInvalidLength
 14591  			}
 14592  			postIndex := iNdEx + intStringLen
 14593  			if postIndex < 0 {
 14594  				return ErrInvalidLength
 14595  			}
 14596  			if postIndex > l {
 14597  				return io.ErrUnexpectedEOF
 14598  			}
 14599  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 14600  			iNdEx = postIndex
 14601  		case 2:
 14602  			if wireType != 2 {
 14603  				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
 14604  			}
 14605  			var stringLen uint64
 14606  			for shift := uint(0); ; shift += 7 {
 14607  				if shift >= 64 {
 14608  					return ErrIntOverflow
 14609  				}
 14610  				if iNdEx >= l {
 14611  					return io.ErrUnexpectedEOF
 14612  				}
 14613  				b := dAtA[iNdEx]
 14614  				iNdEx++
 14615  				stringLen |= uint64(b&0x7F) << shift
 14616  				if b < 0x80 {
 14617  					break
 14618  				}
 14619  			}
 14620  			intStringLen := int(stringLen)
 14621  			if intStringLen < 0 {
 14622  				return ErrInvalidLength
 14623  			}
 14624  			postIndex := iNdEx + intStringLen
 14625  			if postIndex < 0 {
 14626  				return ErrInvalidLength
 14627  			}
 14628  			if postIndex > l {
 14629  				return io.ErrUnexpectedEOF
 14630  			}
 14631  			m.Path = string(dAtA[iNdEx:postIndex])
 14632  			iNdEx = postIndex
 14633  		default:
 14634  			iNdEx = preIndex
 14635  			skippy, err := skip(dAtA[iNdEx:])
 14636  			if err != nil {
 14637  				return err
 14638  			}
 14639  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14640  				return ErrInvalidLength
 14641  			}
 14642  			if (iNdEx + skippy) > l {
 14643  				return io.ErrUnexpectedEOF
 14644  			}
 14645  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14646  			iNdEx += skippy
 14647  		}
 14648  	}
 14649  
 14650  	if iNdEx > l {
 14651  		return io.ErrUnexpectedEOF
 14652  	}
 14653  	return nil
 14654  }
 14655  func (m *GetVSchemaRequest) UnmarshalVT(dAtA []byte) error {
 14656  	l := len(dAtA)
 14657  	iNdEx := 0
 14658  	for iNdEx < l {
 14659  		preIndex := iNdEx
 14660  		var wire uint64
 14661  		for shift := uint(0); ; shift += 7 {
 14662  			if shift >= 64 {
 14663  				return ErrIntOverflow
 14664  			}
 14665  			if iNdEx >= l {
 14666  				return io.ErrUnexpectedEOF
 14667  			}
 14668  			b := dAtA[iNdEx]
 14669  			iNdEx++
 14670  			wire |= uint64(b&0x7F) << shift
 14671  			if b < 0x80 {
 14672  				break
 14673  			}
 14674  		}
 14675  		fieldNum := int32(wire >> 3)
 14676  		wireType := int(wire & 0x7)
 14677  		if wireType == 4 {
 14678  			return fmt.Errorf("proto: GetVSchemaRequest: wiretype end group for non-group")
 14679  		}
 14680  		if fieldNum <= 0 {
 14681  			return fmt.Errorf("proto: GetVSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14682  		}
 14683  		switch fieldNum {
 14684  		case 1:
 14685  			if wireType != 2 {
 14686  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 14687  			}
 14688  			var stringLen uint64
 14689  			for shift := uint(0); ; shift += 7 {
 14690  				if shift >= 64 {
 14691  					return ErrIntOverflow
 14692  				}
 14693  				if iNdEx >= l {
 14694  					return io.ErrUnexpectedEOF
 14695  				}
 14696  				b := dAtA[iNdEx]
 14697  				iNdEx++
 14698  				stringLen |= uint64(b&0x7F) << shift
 14699  				if b < 0x80 {
 14700  					break
 14701  				}
 14702  			}
 14703  			intStringLen := int(stringLen)
 14704  			if intStringLen < 0 {
 14705  				return ErrInvalidLength
 14706  			}
 14707  			postIndex := iNdEx + intStringLen
 14708  			if postIndex < 0 {
 14709  				return ErrInvalidLength
 14710  			}
 14711  			if postIndex > l {
 14712  				return io.ErrUnexpectedEOF
 14713  			}
 14714  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 14715  			iNdEx = postIndex
 14716  		case 2:
 14717  			if wireType != 2 {
 14718  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 14719  			}
 14720  			var stringLen uint64
 14721  			for shift := uint(0); ; shift += 7 {
 14722  				if shift >= 64 {
 14723  					return ErrIntOverflow
 14724  				}
 14725  				if iNdEx >= l {
 14726  					return io.ErrUnexpectedEOF
 14727  				}
 14728  				b := dAtA[iNdEx]
 14729  				iNdEx++
 14730  				stringLen |= uint64(b&0x7F) << shift
 14731  				if b < 0x80 {
 14732  					break
 14733  				}
 14734  			}
 14735  			intStringLen := int(stringLen)
 14736  			if intStringLen < 0 {
 14737  				return ErrInvalidLength
 14738  			}
 14739  			postIndex := iNdEx + intStringLen
 14740  			if postIndex < 0 {
 14741  				return ErrInvalidLength
 14742  			}
 14743  			if postIndex > l {
 14744  				return io.ErrUnexpectedEOF
 14745  			}
 14746  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 14747  			iNdEx = postIndex
 14748  		default:
 14749  			iNdEx = preIndex
 14750  			skippy, err := skip(dAtA[iNdEx:])
 14751  			if err != nil {
 14752  				return err
 14753  			}
 14754  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14755  				return ErrInvalidLength
 14756  			}
 14757  			if (iNdEx + skippy) > l {
 14758  				return io.ErrUnexpectedEOF
 14759  			}
 14760  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14761  			iNdEx += skippy
 14762  		}
 14763  	}
 14764  
 14765  	if iNdEx > l {
 14766  		return io.ErrUnexpectedEOF
 14767  	}
 14768  	return nil
 14769  }
 14770  func (m *GetVSchemasRequest) UnmarshalVT(dAtA []byte) error {
 14771  	l := len(dAtA)
 14772  	iNdEx := 0
 14773  	for iNdEx < l {
 14774  		preIndex := iNdEx
 14775  		var wire uint64
 14776  		for shift := uint(0); ; shift += 7 {
 14777  			if shift >= 64 {
 14778  				return ErrIntOverflow
 14779  			}
 14780  			if iNdEx >= l {
 14781  				return io.ErrUnexpectedEOF
 14782  			}
 14783  			b := dAtA[iNdEx]
 14784  			iNdEx++
 14785  			wire |= uint64(b&0x7F) << shift
 14786  			if b < 0x80 {
 14787  				break
 14788  			}
 14789  		}
 14790  		fieldNum := int32(wire >> 3)
 14791  		wireType := int(wire & 0x7)
 14792  		if wireType == 4 {
 14793  			return fmt.Errorf("proto: GetVSchemasRequest: wiretype end group for non-group")
 14794  		}
 14795  		if fieldNum <= 0 {
 14796  			return fmt.Errorf("proto: GetVSchemasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14797  		}
 14798  		switch fieldNum {
 14799  		case 1:
 14800  			if wireType != 2 {
 14801  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 14802  			}
 14803  			var stringLen uint64
 14804  			for shift := uint(0); ; shift += 7 {
 14805  				if shift >= 64 {
 14806  					return ErrIntOverflow
 14807  				}
 14808  				if iNdEx >= l {
 14809  					return io.ErrUnexpectedEOF
 14810  				}
 14811  				b := dAtA[iNdEx]
 14812  				iNdEx++
 14813  				stringLen |= uint64(b&0x7F) << shift
 14814  				if b < 0x80 {
 14815  					break
 14816  				}
 14817  			}
 14818  			intStringLen := int(stringLen)
 14819  			if intStringLen < 0 {
 14820  				return ErrInvalidLength
 14821  			}
 14822  			postIndex := iNdEx + intStringLen
 14823  			if postIndex < 0 {
 14824  				return ErrInvalidLength
 14825  			}
 14826  			if postIndex > l {
 14827  				return io.ErrUnexpectedEOF
 14828  			}
 14829  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 14830  			iNdEx = postIndex
 14831  		default:
 14832  			iNdEx = preIndex
 14833  			skippy, err := skip(dAtA[iNdEx:])
 14834  			if err != nil {
 14835  				return err
 14836  			}
 14837  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14838  				return ErrInvalidLength
 14839  			}
 14840  			if (iNdEx + skippy) > l {
 14841  				return io.ErrUnexpectedEOF
 14842  			}
 14843  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14844  			iNdEx += skippy
 14845  		}
 14846  	}
 14847  
 14848  	if iNdEx > l {
 14849  		return io.ErrUnexpectedEOF
 14850  	}
 14851  	return nil
 14852  }
 14853  func (m *GetVSchemasResponse) UnmarshalVT(dAtA []byte) error {
 14854  	l := len(dAtA)
 14855  	iNdEx := 0
 14856  	for iNdEx < l {
 14857  		preIndex := iNdEx
 14858  		var wire uint64
 14859  		for shift := uint(0); ; shift += 7 {
 14860  			if shift >= 64 {
 14861  				return ErrIntOverflow
 14862  			}
 14863  			if iNdEx >= l {
 14864  				return io.ErrUnexpectedEOF
 14865  			}
 14866  			b := dAtA[iNdEx]
 14867  			iNdEx++
 14868  			wire |= uint64(b&0x7F) << shift
 14869  			if b < 0x80 {
 14870  				break
 14871  			}
 14872  		}
 14873  		fieldNum := int32(wire >> 3)
 14874  		wireType := int(wire & 0x7)
 14875  		if wireType == 4 {
 14876  			return fmt.Errorf("proto: GetVSchemasResponse: wiretype end group for non-group")
 14877  		}
 14878  		if fieldNum <= 0 {
 14879  			return fmt.Errorf("proto: GetVSchemasResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14880  		}
 14881  		switch fieldNum {
 14882  		case 1:
 14883  			if wireType != 2 {
 14884  				return fmt.Errorf("proto: wrong wireType = %d for field VSchemas", wireType)
 14885  			}
 14886  			var msglen int
 14887  			for shift := uint(0); ; shift += 7 {
 14888  				if shift >= 64 {
 14889  					return ErrIntOverflow
 14890  				}
 14891  				if iNdEx >= l {
 14892  					return io.ErrUnexpectedEOF
 14893  				}
 14894  				b := dAtA[iNdEx]
 14895  				iNdEx++
 14896  				msglen |= int(b&0x7F) << shift
 14897  				if b < 0x80 {
 14898  					break
 14899  				}
 14900  			}
 14901  			if msglen < 0 {
 14902  				return ErrInvalidLength
 14903  			}
 14904  			postIndex := iNdEx + msglen
 14905  			if postIndex < 0 {
 14906  				return ErrInvalidLength
 14907  			}
 14908  			if postIndex > l {
 14909  				return io.ErrUnexpectedEOF
 14910  			}
 14911  			m.VSchemas = append(m.VSchemas, &VSchema{})
 14912  			if err := m.VSchemas[len(m.VSchemas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14913  				return err
 14914  			}
 14915  			iNdEx = postIndex
 14916  		default:
 14917  			iNdEx = preIndex
 14918  			skippy, err := skip(dAtA[iNdEx:])
 14919  			if err != nil {
 14920  				return err
 14921  			}
 14922  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14923  				return ErrInvalidLength
 14924  			}
 14925  			if (iNdEx + skippy) > l {
 14926  				return io.ErrUnexpectedEOF
 14927  			}
 14928  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14929  			iNdEx += skippy
 14930  		}
 14931  	}
 14932  
 14933  	if iNdEx > l {
 14934  		return io.ErrUnexpectedEOF
 14935  	}
 14936  	return nil
 14937  }
 14938  func (m *GetVtctldsRequest) UnmarshalVT(dAtA []byte) error {
 14939  	l := len(dAtA)
 14940  	iNdEx := 0
 14941  	for iNdEx < l {
 14942  		preIndex := iNdEx
 14943  		var wire uint64
 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  			wire |= uint64(b&0x7F) << shift
 14954  			if b < 0x80 {
 14955  				break
 14956  			}
 14957  		}
 14958  		fieldNum := int32(wire >> 3)
 14959  		wireType := int(wire & 0x7)
 14960  		if wireType == 4 {
 14961  			return fmt.Errorf("proto: GetVtctldsRequest: wiretype end group for non-group")
 14962  		}
 14963  		if fieldNum <= 0 {
 14964  			return fmt.Errorf("proto: GetVtctldsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14965  		}
 14966  		switch fieldNum {
 14967  		case 1:
 14968  			if wireType != 2 {
 14969  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 14970  			}
 14971  			var stringLen uint64
 14972  			for shift := uint(0); ; shift += 7 {
 14973  				if shift >= 64 {
 14974  					return ErrIntOverflow
 14975  				}
 14976  				if iNdEx >= l {
 14977  					return io.ErrUnexpectedEOF
 14978  				}
 14979  				b := dAtA[iNdEx]
 14980  				iNdEx++
 14981  				stringLen |= uint64(b&0x7F) << shift
 14982  				if b < 0x80 {
 14983  					break
 14984  				}
 14985  			}
 14986  			intStringLen := int(stringLen)
 14987  			if intStringLen < 0 {
 14988  				return ErrInvalidLength
 14989  			}
 14990  			postIndex := iNdEx + intStringLen
 14991  			if postIndex < 0 {
 14992  				return ErrInvalidLength
 14993  			}
 14994  			if postIndex > l {
 14995  				return io.ErrUnexpectedEOF
 14996  			}
 14997  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 14998  			iNdEx = postIndex
 14999  		default:
 15000  			iNdEx = preIndex
 15001  			skippy, err := skip(dAtA[iNdEx:])
 15002  			if err != nil {
 15003  				return err
 15004  			}
 15005  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15006  				return ErrInvalidLength
 15007  			}
 15008  			if (iNdEx + skippy) > l {
 15009  				return io.ErrUnexpectedEOF
 15010  			}
 15011  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15012  			iNdEx += skippy
 15013  		}
 15014  	}
 15015  
 15016  	if iNdEx > l {
 15017  		return io.ErrUnexpectedEOF
 15018  	}
 15019  	return nil
 15020  }
 15021  func (m *GetVtctldsResponse) UnmarshalVT(dAtA []byte) error {
 15022  	l := len(dAtA)
 15023  	iNdEx := 0
 15024  	for iNdEx < l {
 15025  		preIndex := iNdEx
 15026  		var wire uint64
 15027  		for shift := uint(0); ; shift += 7 {
 15028  			if shift >= 64 {
 15029  				return ErrIntOverflow
 15030  			}
 15031  			if iNdEx >= l {
 15032  				return io.ErrUnexpectedEOF
 15033  			}
 15034  			b := dAtA[iNdEx]
 15035  			iNdEx++
 15036  			wire |= uint64(b&0x7F) << shift
 15037  			if b < 0x80 {
 15038  				break
 15039  			}
 15040  		}
 15041  		fieldNum := int32(wire >> 3)
 15042  		wireType := int(wire & 0x7)
 15043  		if wireType == 4 {
 15044  			return fmt.Errorf("proto: GetVtctldsResponse: wiretype end group for non-group")
 15045  		}
 15046  		if fieldNum <= 0 {
 15047  			return fmt.Errorf("proto: GetVtctldsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15048  		}
 15049  		switch fieldNum {
 15050  		case 1:
 15051  			if wireType != 2 {
 15052  				return fmt.Errorf("proto: wrong wireType = %d for field Vtctlds", wireType)
 15053  			}
 15054  			var msglen int
 15055  			for shift := uint(0); ; shift += 7 {
 15056  				if shift >= 64 {
 15057  					return ErrIntOverflow
 15058  				}
 15059  				if iNdEx >= l {
 15060  					return io.ErrUnexpectedEOF
 15061  				}
 15062  				b := dAtA[iNdEx]
 15063  				iNdEx++
 15064  				msglen |= int(b&0x7F) << shift
 15065  				if b < 0x80 {
 15066  					break
 15067  				}
 15068  			}
 15069  			if msglen < 0 {
 15070  				return ErrInvalidLength
 15071  			}
 15072  			postIndex := iNdEx + msglen
 15073  			if postIndex < 0 {
 15074  				return ErrInvalidLength
 15075  			}
 15076  			if postIndex > l {
 15077  				return io.ErrUnexpectedEOF
 15078  			}
 15079  			m.Vtctlds = append(m.Vtctlds, &Vtctld{})
 15080  			if err := m.Vtctlds[len(m.Vtctlds)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15081  				return err
 15082  			}
 15083  			iNdEx = postIndex
 15084  		default:
 15085  			iNdEx = preIndex
 15086  			skippy, err := skip(dAtA[iNdEx:])
 15087  			if err != nil {
 15088  				return err
 15089  			}
 15090  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15091  				return ErrInvalidLength
 15092  			}
 15093  			if (iNdEx + skippy) > l {
 15094  				return io.ErrUnexpectedEOF
 15095  			}
 15096  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15097  			iNdEx += skippy
 15098  		}
 15099  	}
 15100  
 15101  	if iNdEx > l {
 15102  		return io.ErrUnexpectedEOF
 15103  	}
 15104  	return nil
 15105  }
 15106  func (m *GetWorkflowRequest) UnmarshalVT(dAtA []byte) error {
 15107  	l := len(dAtA)
 15108  	iNdEx := 0
 15109  	for iNdEx < l {
 15110  		preIndex := iNdEx
 15111  		var wire uint64
 15112  		for shift := uint(0); ; shift += 7 {
 15113  			if shift >= 64 {
 15114  				return ErrIntOverflow
 15115  			}
 15116  			if iNdEx >= l {
 15117  				return io.ErrUnexpectedEOF
 15118  			}
 15119  			b := dAtA[iNdEx]
 15120  			iNdEx++
 15121  			wire |= uint64(b&0x7F) << shift
 15122  			if b < 0x80 {
 15123  				break
 15124  			}
 15125  		}
 15126  		fieldNum := int32(wire >> 3)
 15127  		wireType := int(wire & 0x7)
 15128  		if wireType == 4 {
 15129  			return fmt.Errorf("proto: GetWorkflowRequest: wiretype end group for non-group")
 15130  		}
 15131  		if fieldNum <= 0 {
 15132  			return fmt.Errorf("proto: GetWorkflowRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15133  		}
 15134  		switch fieldNum {
 15135  		case 1:
 15136  			if wireType != 2 {
 15137  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 15138  			}
 15139  			var stringLen uint64
 15140  			for shift := uint(0); ; shift += 7 {
 15141  				if shift >= 64 {
 15142  					return ErrIntOverflow
 15143  				}
 15144  				if iNdEx >= l {
 15145  					return io.ErrUnexpectedEOF
 15146  				}
 15147  				b := dAtA[iNdEx]
 15148  				iNdEx++
 15149  				stringLen |= uint64(b&0x7F) << shift
 15150  				if b < 0x80 {
 15151  					break
 15152  				}
 15153  			}
 15154  			intStringLen := int(stringLen)
 15155  			if intStringLen < 0 {
 15156  				return ErrInvalidLength
 15157  			}
 15158  			postIndex := iNdEx + intStringLen
 15159  			if postIndex < 0 {
 15160  				return ErrInvalidLength
 15161  			}
 15162  			if postIndex > l {
 15163  				return io.ErrUnexpectedEOF
 15164  			}
 15165  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 15166  			iNdEx = postIndex
 15167  		case 2:
 15168  			if wireType != 2 {
 15169  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 15170  			}
 15171  			var stringLen uint64
 15172  			for shift := uint(0); ; shift += 7 {
 15173  				if shift >= 64 {
 15174  					return ErrIntOverflow
 15175  				}
 15176  				if iNdEx >= l {
 15177  					return io.ErrUnexpectedEOF
 15178  				}
 15179  				b := dAtA[iNdEx]
 15180  				iNdEx++
 15181  				stringLen |= uint64(b&0x7F) << shift
 15182  				if b < 0x80 {
 15183  					break
 15184  				}
 15185  			}
 15186  			intStringLen := int(stringLen)
 15187  			if intStringLen < 0 {
 15188  				return ErrInvalidLength
 15189  			}
 15190  			postIndex := iNdEx + intStringLen
 15191  			if postIndex < 0 {
 15192  				return ErrInvalidLength
 15193  			}
 15194  			if postIndex > l {
 15195  				return io.ErrUnexpectedEOF
 15196  			}
 15197  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 15198  			iNdEx = postIndex
 15199  		case 3:
 15200  			if wireType != 2 {
 15201  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 15202  			}
 15203  			var stringLen uint64
 15204  			for shift := uint(0); ; shift += 7 {
 15205  				if shift >= 64 {
 15206  					return ErrIntOverflow
 15207  				}
 15208  				if iNdEx >= l {
 15209  					return io.ErrUnexpectedEOF
 15210  				}
 15211  				b := dAtA[iNdEx]
 15212  				iNdEx++
 15213  				stringLen |= uint64(b&0x7F) << shift
 15214  				if b < 0x80 {
 15215  					break
 15216  				}
 15217  			}
 15218  			intStringLen := int(stringLen)
 15219  			if intStringLen < 0 {
 15220  				return ErrInvalidLength
 15221  			}
 15222  			postIndex := iNdEx + intStringLen
 15223  			if postIndex < 0 {
 15224  				return ErrInvalidLength
 15225  			}
 15226  			if postIndex > l {
 15227  				return io.ErrUnexpectedEOF
 15228  			}
 15229  			m.Name = string(dAtA[iNdEx:postIndex])
 15230  			iNdEx = postIndex
 15231  		case 4:
 15232  			if wireType != 0 {
 15233  				return fmt.Errorf("proto: wrong wireType = %d for field ActiveOnly", wireType)
 15234  			}
 15235  			var v int
 15236  			for shift := uint(0); ; shift += 7 {
 15237  				if shift >= 64 {
 15238  					return ErrIntOverflow
 15239  				}
 15240  				if iNdEx >= l {
 15241  					return io.ErrUnexpectedEOF
 15242  				}
 15243  				b := dAtA[iNdEx]
 15244  				iNdEx++
 15245  				v |= int(b&0x7F) << shift
 15246  				if b < 0x80 {
 15247  					break
 15248  				}
 15249  			}
 15250  			m.ActiveOnly = bool(v != 0)
 15251  		default:
 15252  			iNdEx = preIndex
 15253  			skippy, err := skip(dAtA[iNdEx:])
 15254  			if err != nil {
 15255  				return err
 15256  			}
 15257  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15258  				return ErrInvalidLength
 15259  			}
 15260  			if (iNdEx + skippy) > l {
 15261  				return io.ErrUnexpectedEOF
 15262  			}
 15263  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15264  			iNdEx += skippy
 15265  		}
 15266  	}
 15267  
 15268  	if iNdEx > l {
 15269  		return io.ErrUnexpectedEOF
 15270  	}
 15271  	return nil
 15272  }
 15273  func (m *GetWorkflowsRequest) UnmarshalVT(dAtA []byte) error {
 15274  	l := len(dAtA)
 15275  	iNdEx := 0
 15276  	for iNdEx < l {
 15277  		preIndex := iNdEx
 15278  		var wire uint64
 15279  		for shift := uint(0); ; shift += 7 {
 15280  			if shift >= 64 {
 15281  				return ErrIntOverflow
 15282  			}
 15283  			if iNdEx >= l {
 15284  				return io.ErrUnexpectedEOF
 15285  			}
 15286  			b := dAtA[iNdEx]
 15287  			iNdEx++
 15288  			wire |= uint64(b&0x7F) << shift
 15289  			if b < 0x80 {
 15290  				break
 15291  			}
 15292  		}
 15293  		fieldNum := int32(wire >> 3)
 15294  		wireType := int(wire & 0x7)
 15295  		if wireType == 4 {
 15296  			return fmt.Errorf("proto: GetWorkflowsRequest: wiretype end group for non-group")
 15297  		}
 15298  		if fieldNum <= 0 {
 15299  			return fmt.Errorf("proto: GetWorkflowsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15300  		}
 15301  		switch fieldNum {
 15302  		case 1:
 15303  			if wireType != 2 {
 15304  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 15305  			}
 15306  			var stringLen uint64
 15307  			for shift := uint(0); ; shift += 7 {
 15308  				if shift >= 64 {
 15309  					return ErrIntOverflow
 15310  				}
 15311  				if iNdEx >= l {
 15312  					return io.ErrUnexpectedEOF
 15313  				}
 15314  				b := dAtA[iNdEx]
 15315  				iNdEx++
 15316  				stringLen |= uint64(b&0x7F) << shift
 15317  				if b < 0x80 {
 15318  					break
 15319  				}
 15320  			}
 15321  			intStringLen := int(stringLen)
 15322  			if intStringLen < 0 {
 15323  				return ErrInvalidLength
 15324  			}
 15325  			postIndex := iNdEx + intStringLen
 15326  			if postIndex < 0 {
 15327  				return ErrInvalidLength
 15328  			}
 15329  			if postIndex > l {
 15330  				return io.ErrUnexpectedEOF
 15331  			}
 15332  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 15333  			iNdEx = postIndex
 15334  		case 2:
 15335  			if wireType != 0 {
 15336  				return fmt.Errorf("proto: wrong wireType = %d for field ActiveOnly", wireType)
 15337  			}
 15338  			var v int
 15339  			for shift := uint(0); ; shift += 7 {
 15340  				if shift >= 64 {
 15341  					return ErrIntOverflow
 15342  				}
 15343  				if iNdEx >= l {
 15344  					return io.ErrUnexpectedEOF
 15345  				}
 15346  				b := dAtA[iNdEx]
 15347  				iNdEx++
 15348  				v |= int(b&0x7F) << shift
 15349  				if b < 0x80 {
 15350  					break
 15351  				}
 15352  			}
 15353  			m.ActiveOnly = bool(v != 0)
 15354  		case 3:
 15355  			if wireType != 2 {
 15356  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspaces", wireType)
 15357  			}
 15358  			var stringLen uint64
 15359  			for shift := uint(0); ; shift += 7 {
 15360  				if shift >= 64 {
 15361  					return ErrIntOverflow
 15362  				}
 15363  				if iNdEx >= l {
 15364  					return io.ErrUnexpectedEOF
 15365  				}
 15366  				b := dAtA[iNdEx]
 15367  				iNdEx++
 15368  				stringLen |= uint64(b&0x7F) << shift
 15369  				if b < 0x80 {
 15370  					break
 15371  				}
 15372  			}
 15373  			intStringLen := int(stringLen)
 15374  			if intStringLen < 0 {
 15375  				return ErrInvalidLength
 15376  			}
 15377  			postIndex := iNdEx + intStringLen
 15378  			if postIndex < 0 {
 15379  				return ErrInvalidLength
 15380  			}
 15381  			if postIndex > l {
 15382  				return io.ErrUnexpectedEOF
 15383  			}
 15384  			m.Keyspaces = append(m.Keyspaces, string(dAtA[iNdEx:postIndex]))
 15385  			iNdEx = postIndex
 15386  		case 4:
 15387  			if wireType != 2 {
 15388  				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreKeyspaces", wireType)
 15389  			}
 15390  			var stringLen uint64
 15391  			for shift := uint(0); ; shift += 7 {
 15392  				if shift >= 64 {
 15393  					return ErrIntOverflow
 15394  				}
 15395  				if iNdEx >= l {
 15396  					return io.ErrUnexpectedEOF
 15397  				}
 15398  				b := dAtA[iNdEx]
 15399  				iNdEx++
 15400  				stringLen |= uint64(b&0x7F) << shift
 15401  				if b < 0x80 {
 15402  					break
 15403  				}
 15404  			}
 15405  			intStringLen := int(stringLen)
 15406  			if intStringLen < 0 {
 15407  				return ErrInvalidLength
 15408  			}
 15409  			postIndex := iNdEx + intStringLen
 15410  			if postIndex < 0 {
 15411  				return ErrInvalidLength
 15412  			}
 15413  			if postIndex > l {
 15414  				return io.ErrUnexpectedEOF
 15415  			}
 15416  			m.IgnoreKeyspaces = append(m.IgnoreKeyspaces, string(dAtA[iNdEx:postIndex]))
 15417  			iNdEx = postIndex
 15418  		default:
 15419  			iNdEx = preIndex
 15420  			skippy, err := skip(dAtA[iNdEx:])
 15421  			if err != nil {
 15422  				return err
 15423  			}
 15424  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15425  				return ErrInvalidLength
 15426  			}
 15427  			if (iNdEx + skippy) > l {
 15428  				return io.ErrUnexpectedEOF
 15429  			}
 15430  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15431  			iNdEx += skippy
 15432  		}
 15433  	}
 15434  
 15435  	if iNdEx > l {
 15436  		return io.ErrUnexpectedEOF
 15437  	}
 15438  	return nil
 15439  }
 15440  func (m *GetWorkflowsResponse) UnmarshalVT(dAtA []byte) error {
 15441  	l := len(dAtA)
 15442  	iNdEx := 0
 15443  	for iNdEx < l {
 15444  		preIndex := iNdEx
 15445  		var wire uint64
 15446  		for shift := uint(0); ; shift += 7 {
 15447  			if shift >= 64 {
 15448  				return ErrIntOverflow
 15449  			}
 15450  			if iNdEx >= l {
 15451  				return io.ErrUnexpectedEOF
 15452  			}
 15453  			b := dAtA[iNdEx]
 15454  			iNdEx++
 15455  			wire |= uint64(b&0x7F) << shift
 15456  			if b < 0x80 {
 15457  				break
 15458  			}
 15459  		}
 15460  		fieldNum := int32(wire >> 3)
 15461  		wireType := int(wire & 0x7)
 15462  		if wireType == 4 {
 15463  			return fmt.Errorf("proto: GetWorkflowsResponse: wiretype end group for non-group")
 15464  		}
 15465  		if fieldNum <= 0 {
 15466  			return fmt.Errorf("proto: GetWorkflowsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15467  		}
 15468  		switch fieldNum {
 15469  		case 1:
 15470  			if wireType != 2 {
 15471  				return fmt.Errorf("proto: wrong wireType = %d for field WorkflowsByCluster", wireType)
 15472  			}
 15473  			var msglen int
 15474  			for shift := uint(0); ; shift += 7 {
 15475  				if shift >= 64 {
 15476  					return ErrIntOverflow
 15477  				}
 15478  				if iNdEx >= l {
 15479  					return io.ErrUnexpectedEOF
 15480  				}
 15481  				b := dAtA[iNdEx]
 15482  				iNdEx++
 15483  				msglen |= int(b&0x7F) << shift
 15484  				if b < 0x80 {
 15485  					break
 15486  				}
 15487  			}
 15488  			if msglen < 0 {
 15489  				return ErrInvalidLength
 15490  			}
 15491  			postIndex := iNdEx + msglen
 15492  			if postIndex < 0 {
 15493  				return ErrInvalidLength
 15494  			}
 15495  			if postIndex > l {
 15496  				return io.ErrUnexpectedEOF
 15497  			}
 15498  			if m.WorkflowsByCluster == nil {
 15499  				m.WorkflowsByCluster = make(map[string]*ClusterWorkflows)
 15500  			}
 15501  			var mapkey string
 15502  			var mapvalue *ClusterWorkflows
 15503  			for iNdEx < postIndex {
 15504  				entryPreIndex := iNdEx
 15505  				var wire uint64
 15506  				for shift := uint(0); ; shift += 7 {
 15507  					if shift >= 64 {
 15508  						return ErrIntOverflow
 15509  					}
 15510  					if iNdEx >= l {
 15511  						return io.ErrUnexpectedEOF
 15512  					}
 15513  					b := dAtA[iNdEx]
 15514  					iNdEx++
 15515  					wire |= uint64(b&0x7F) << shift
 15516  					if b < 0x80 {
 15517  						break
 15518  					}
 15519  				}
 15520  				fieldNum := int32(wire >> 3)
 15521  				if fieldNum == 1 {
 15522  					var stringLenmapkey uint64
 15523  					for shift := uint(0); ; shift += 7 {
 15524  						if shift >= 64 {
 15525  							return ErrIntOverflow
 15526  						}
 15527  						if iNdEx >= l {
 15528  							return io.ErrUnexpectedEOF
 15529  						}
 15530  						b := dAtA[iNdEx]
 15531  						iNdEx++
 15532  						stringLenmapkey |= uint64(b&0x7F) << shift
 15533  						if b < 0x80 {
 15534  							break
 15535  						}
 15536  					}
 15537  					intStringLenmapkey := int(stringLenmapkey)
 15538  					if intStringLenmapkey < 0 {
 15539  						return ErrInvalidLength
 15540  					}
 15541  					postStringIndexmapkey := iNdEx + intStringLenmapkey
 15542  					if postStringIndexmapkey < 0 {
 15543  						return ErrInvalidLength
 15544  					}
 15545  					if postStringIndexmapkey > l {
 15546  						return io.ErrUnexpectedEOF
 15547  					}
 15548  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 15549  					iNdEx = postStringIndexmapkey
 15550  				} else if fieldNum == 2 {
 15551  					var mapmsglen int
 15552  					for shift := uint(0); ; shift += 7 {
 15553  						if shift >= 64 {
 15554  							return ErrIntOverflow
 15555  						}
 15556  						if iNdEx >= l {
 15557  							return io.ErrUnexpectedEOF
 15558  						}
 15559  						b := dAtA[iNdEx]
 15560  						iNdEx++
 15561  						mapmsglen |= int(b&0x7F) << shift
 15562  						if b < 0x80 {
 15563  							break
 15564  						}
 15565  					}
 15566  					if mapmsglen < 0 {
 15567  						return ErrInvalidLength
 15568  					}
 15569  					postmsgIndex := iNdEx + mapmsglen
 15570  					if postmsgIndex < 0 {
 15571  						return ErrInvalidLength
 15572  					}
 15573  					if postmsgIndex > l {
 15574  						return io.ErrUnexpectedEOF
 15575  					}
 15576  					mapvalue = &ClusterWorkflows{}
 15577  					if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {
 15578  						return err
 15579  					}
 15580  					iNdEx = postmsgIndex
 15581  				} else {
 15582  					iNdEx = entryPreIndex
 15583  					skippy, err := skip(dAtA[iNdEx:])
 15584  					if err != nil {
 15585  						return err
 15586  					}
 15587  					if (skippy < 0) || (iNdEx+skippy) < 0 {
 15588  						return ErrInvalidLength
 15589  					}
 15590  					if (iNdEx + skippy) > postIndex {
 15591  						return io.ErrUnexpectedEOF
 15592  					}
 15593  					iNdEx += skippy
 15594  				}
 15595  			}
 15596  			m.WorkflowsByCluster[mapkey] = mapvalue
 15597  			iNdEx = postIndex
 15598  		default:
 15599  			iNdEx = preIndex
 15600  			skippy, err := skip(dAtA[iNdEx:])
 15601  			if err != nil {
 15602  				return err
 15603  			}
 15604  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15605  				return ErrInvalidLength
 15606  			}
 15607  			if (iNdEx + skippy) > l {
 15608  				return io.ErrUnexpectedEOF
 15609  			}
 15610  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15611  			iNdEx += skippy
 15612  		}
 15613  	}
 15614  
 15615  	if iNdEx > l {
 15616  		return io.ErrUnexpectedEOF
 15617  	}
 15618  	return nil
 15619  }
 15620  func (m *PingTabletRequest) UnmarshalVT(dAtA []byte) error {
 15621  	l := len(dAtA)
 15622  	iNdEx := 0
 15623  	for iNdEx < l {
 15624  		preIndex := iNdEx
 15625  		var wire uint64
 15626  		for shift := uint(0); ; shift += 7 {
 15627  			if shift >= 64 {
 15628  				return ErrIntOverflow
 15629  			}
 15630  			if iNdEx >= l {
 15631  				return io.ErrUnexpectedEOF
 15632  			}
 15633  			b := dAtA[iNdEx]
 15634  			iNdEx++
 15635  			wire |= uint64(b&0x7F) << shift
 15636  			if b < 0x80 {
 15637  				break
 15638  			}
 15639  		}
 15640  		fieldNum := int32(wire >> 3)
 15641  		wireType := int(wire & 0x7)
 15642  		if wireType == 4 {
 15643  			return fmt.Errorf("proto: PingTabletRequest: wiretype end group for non-group")
 15644  		}
 15645  		if fieldNum <= 0 {
 15646  			return fmt.Errorf("proto: PingTabletRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15647  		}
 15648  		switch fieldNum {
 15649  		case 1:
 15650  			if wireType != 2 {
 15651  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 15652  			}
 15653  			var msglen int
 15654  			for shift := uint(0); ; shift += 7 {
 15655  				if shift >= 64 {
 15656  					return ErrIntOverflow
 15657  				}
 15658  				if iNdEx >= l {
 15659  					return io.ErrUnexpectedEOF
 15660  				}
 15661  				b := dAtA[iNdEx]
 15662  				iNdEx++
 15663  				msglen |= int(b&0x7F) << shift
 15664  				if b < 0x80 {
 15665  					break
 15666  				}
 15667  			}
 15668  			if msglen < 0 {
 15669  				return ErrInvalidLength
 15670  			}
 15671  			postIndex := iNdEx + msglen
 15672  			if postIndex < 0 {
 15673  				return ErrInvalidLength
 15674  			}
 15675  			if postIndex > l {
 15676  				return io.ErrUnexpectedEOF
 15677  			}
 15678  			if m.Alias == nil {
 15679  				m.Alias = &topodata.TabletAlias{}
 15680  			}
 15681  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15682  				return err
 15683  			}
 15684  			iNdEx = postIndex
 15685  		case 2:
 15686  			if wireType != 2 {
 15687  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 15688  			}
 15689  			var stringLen uint64
 15690  			for shift := uint(0); ; shift += 7 {
 15691  				if shift >= 64 {
 15692  					return ErrIntOverflow
 15693  				}
 15694  				if iNdEx >= l {
 15695  					return io.ErrUnexpectedEOF
 15696  				}
 15697  				b := dAtA[iNdEx]
 15698  				iNdEx++
 15699  				stringLen |= uint64(b&0x7F) << shift
 15700  				if b < 0x80 {
 15701  					break
 15702  				}
 15703  			}
 15704  			intStringLen := int(stringLen)
 15705  			if intStringLen < 0 {
 15706  				return ErrInvalidLength
 15707  			}
 15708  			postIndex := iNdEx + intStringLen
 15709  			if postIndex < 0 {
 15710  				return ErrInvalidLength
 15711  			}
 15712  			if postIndex > l {
 15713  				return io.ErrUnexpectedEOF
 15714  			}
 15715  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 15716  			iNdEx = postIndex
 15717  		default:
 15718  			iNdEx = preIndex
 15719  			skippy, err := skip(dAtA[iNdEx:])
 15720  			if err != nil {
 15721  				return err
 15722  			}
 15723  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15724  				return ErrInvalidLength
 15725  			}
 15726  			if (iNdEx + skippy) > l {
 15727  				return io.ErrUnexpectedEOF
 15728  			}
 15729  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15730  			iNdEx += skippy
 15731  		}
 15732  	}
 15733  
 15734  	if iNdEx > l {
 15735  		return io.ErrUnexpectedEOF
 15736  	}
 15737  	return nil
 15738  }
 15739  func (m *PingTabletResponse) UnmarshalVT(dAtA []byte) error {
 15740  	l := len(dAtA)
 15741  	iNdEx := 0
 15742  	for iNdEx < l {
 15743  		preIndex := iNdEx
 15744  		var wire uint64
 15745  		for shift := uint(0); ; shift += 7 {
 15746  			if shift >= 64 {
 15747  				return ErrIntOverflow
 15748  			}
 15749  			if iNdEx >= l {
 15750  				return io.ErrUnexpectedEOF
 15751  			}
 15752  			b := dAtA[iNdEx]
 15753  			iNdEx++
 15754  			wire |= uint64(b&0x7F) << shift
 15755  			if b < 0x80 {
 15756  				break
 15757  			}
 15758  		}
 15759  		fieldNum := int32(wire >> 3)
 15760  		wireType := int(wire & 0x7)
 15761  		if wireType == 4 {
 15762  			return fmt.Errorf("proto: PingTabletResponse: wiretype end group for non-group")
 15763  		}
 15764  		if fieldNum <= 0 {
 15765  			return fmt.Errorf("proto: PingTabletResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15766  		}
 15767  		switch fieldNum {
 15768  		case 1:
 15769  			if wireType != 2 {
 15770  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 15771  			}
 15772  			var stringLen uint64
 15773  			for shift := uint(0); ; shift += 7 {
 15774  				if shift >= 64 {
 15775  					return ErrIntOverflow
 15776  				}
 15777  				if iNdEx >= l {
 15778  					return io.ErrUnexpectedEOF
 15779  				}
 15780  				b := dAtA[iNdEx]
 15781  				iNdEx++
 15782  				stringLen |= uint64(b&0x7F) << shift
 15783  				if b < 0x80 {
 15784  					break
 15785  				}
 15786  			}
 15787  			intStringLen := int(stringLen)
 15788  			if intStringLen < 0 {
 15789  				return ErrInvalidLength
 15790  			}
 15791  			postIndex := iNdEx + intStringLen
 15792  			if postIndex < 0 {
 15793  				return ErrInvalidLength
 15794  			}
 15795  			if postIndex > l {
 15796  				return io.ErrUnexpectedEOF
 15797  			}
 15798  			m.Status = string(dAtA[iNdEx:postIndex])
 15799  			iNdEx = postIndex
 15800  		case 2:
 15801  			if wireType != 2 {
 15802  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 15803  			}
 15804  			var msglen int
 15805  			for shift := uint(0); ; shift += 7 {
 15806  				if shift >= 64 {
 15807  					return ErrIntOverflow
 15808  				}
 15809  				if iNdEx >= l {
 15810  					return io.ErrUnexpectedEOF
 15811  				}
 15812  				b := dAtA[iNdEx]
 15813  				iNdEx++
 15814  				msglen |= int(b&0x7F) << shift
 15815  				if b < 0x80 {
 15816  					break
 15817  				}
 15818  			}
 15819  			if msglen < 0 {
 15820  				return ErrInvalidLength
 15821  			}
 15822  			postIndex := iNdEx + msglen
 15823  			if postIndex < 0 {
 15824  				return ErrInvalidLength
 15825  			}
 15826  			if postIndex > l {
 15827  				return io.ErrUnexpectedEOF
 15828  			}
 15829  			if m.Cluster == nil {
 15830  				m.Cluster = &Cluster{}
 15831  			}
 15832  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15833  				return err
 15834  			}
 15835  			iNdEx = postIndex
 15836  		default:
 15837  			iNdEx = preIndex
 15838  			skippy, err := skip(dAtA[iNdEx:])
 15839  			if err != nil {
 15840  				return err
 15841  			}
 15842  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15843  				return ErrInvalidLength
 15844  			}
 15845  			if (iNdEx + skippy) > l {
 15846  				return io.ErrUnexpectedEOF
 15847  			}
 15848  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15849  			iNdEx += skippy
 15850  		}
 15851  	}
 15852  
 15853  	if iNdEx > l {
 15854  		return io.ErrUnexpectedEOF
 15855  	}
 15856  	return nil
 15857  }
 15858  func (m *PlannedFailoverShardRequest) UnmarshalVT(dAtA []byte) error {
 15859  	l := len(dAtA)
 15860  	iNdEx := 0
 15861  	for iNdEx < l {
 15862  		preIndex := iNdEx
 15863  		var wire uint64
 15864  		for shift := uint(0); ; shift += 7 {
 15865  			if shift >= 64 {
 15866  				return ErrIntOverflow
 15867  			}
 15868  			if iNdEx >= l {
 15869  				return io.ErrUnexpectedEOF
 15870  			}
 15871  			b := dAtA[iNdEx]
 15872  			iNdEx++
 15873  			wire |= uint64(b&0x7F) << shift
 15874  			if b < 0x80 {
 15875  				break
 15876  			}
 15877  		}
 15878  		fieldNum := int32(wire >> 3)
 15879  		wireType := int(wire & 0x7)
 15880  		if wireType == 4 {
 15881  			return fmt.Errorf("proto: PlannedFailoverShardRequest: wiretype end group for non-group")
 15882  		}
 15883  		if fieldNum <= 0 {
 15884  			return fmt.Errorf("proto: PlannedFailoverShardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15885  		}
 15886  		switch fieldNum {
 15887  		case 1:
 15888  			if wireType != 2 {
 15889  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 15890  			}
 15891  			var stringLen uint64
 15892  			for shift := uint(0); ; shift += 7 {
 15893  				if shift >= 64 {
 15894  					return ErrIntOverflow
 15895  				}
 15896  				if iNdEx >= l {
 15897  					return io.ErrUnexpectedEOF
 15898  				}
 15899  				b := dAtA[iNdEx]
 15900  				iNdEx++
 15901  				stringLen |= uint64(b&0x7F) << shift
 15902  				if b < 0x80 {
 15903  					break
 15904  				}
 15905  			}
 15906  			intStringLen := int(stringLen)
 15907  			if intStringLen < 0 {
 15908  				return ErrInvalidLength
 15909  			}
 15910  			postIndex := iNdEx + intStringLen
 15911  			if postIndex < 0 {
 15912  				return ErrInvalidLength
 15913  			}
 15914  			if postIndex > l {
 15915  				return io.ErrUnexpectedEOF
 15916  			}
 15917  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 15918  			iNdEx = postIndex
 15919  		case 2:
 15920  			if wireType != 2 {
 15921  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 15922  			}
 15923  			var msglen int
 15924  			for shift := uint(0); ; shift += 7 {
 15925  				if shift >= 64 {
 15926  					return ErrIntOverflow
 15927  				}
 15928  				if iNdEx >= l {
 15929  					return io.ErrUnexpectedEOF
 15930  				}
 15931  				b := dAtA[iNdEx]
 15932  				iNdEx++
 15933  				msglen |= int(b&0x7F) << shift
 15934  				if b < 0x80 {
 15935  					break
 15936  				}
 15937  			}
 15938  			if msglen < 0 {
 15939  				return ErrInvalidLength
 15940  			}
 15941  			postIndex := iNdEx + msglen
 15942  			if postIndex < 0 {
 15943  				return ErrInvalidLength
 15944  			}
 15945  			if postIndex > l {
 15946  				return io.ErrUnexpectedEOF
 15947  			}
 15948  			if m.Options == nil {
 15949  				m.Options = &vtctldata.PlannedReparentShardRequest{}
 15950  			}
 15951  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15952  				return err
 15953  			}
 15954  			iNdEx = postIndex
 15955  		default:
 15956  			iNdEx = preIndex
 15957  			skippy, err := skip(dAtA[iNdEx:])
 15958  			if err != nil {
 15959  				return err
 15960  			}
 15961  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15962  				return ErrInvalidLength
 15963  			}
 15964  			if (iNdEx + skippy) > l {
 15965  				return io.ErrUnexpectedEOF
 15966  			}
 15967  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15968  			iNdEx += skippy
 15969  		}
 15970  	}
 15971  
 15972  	if iNdEx > l {
 15973  		return io.ErrUnexpectedEOF
 15974  	}
 15975  	return nil
 15976  }
 15977  func (m *PlannedFailoverShardResponse) UnmarshalVT(dAtA []byte) error {
 15978  	l := len(dAtA)
 15979  	iNdEx := 0
 15980  	for iNdEx < l {
 15981  		preIndex := iNdEx
 15982  		var wire uint64
 15983  		for shift := uint(0); ; shift += 7 {
 15984  			if shift >= 64 {
 15985  				return ErrIntOverflow
 15986  			}
 15987  			if iNdEx >= l {
 15988  				return io.ErrUnexpectedEOF
 15989  			}
 15990  			b := dAtA[iNdEx]
 15991  			iNdEx++
 15992  			wire |= uint64(b&0x7F) << shift
 15993  			if b < 0x80 {
 15994  				break
 15995  			}
 15996  		}
 15997  		fieldNum := int32(wire >> 3)
 15998  		wireType := int(wire & 0x7)
 15999  		if wireType == 4 {
 16000  			return fmt.Errorf("proto: PlannedFailoverShardResponse: wiretype end group for non-group")
 16001  		}
 16002  		if fieldNum <= 0 {
 16003  			return fmt.Errorf("proto: PlannedFailoverShardResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 16004  		}
 16005  		switch fieldNum {
 16006  		case 1:
 16007  			if wireType != 2 {
 16008  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 16009  			}
 16010  			var msglen int
 16011  			for shift := uint(0); ; shift += 7 {
 16012  				if shift >= 64 {
 16013  					return ErrIntOverflow
 16014  				}
 16015  				if iNdEx >= l {
 16016  					return io.ErrUnexpectedEOF
 16017  				}
 16018  				b := dAtA[iNdEx]
 16019  				iNdEx++
 16020  				msglen |= int(b&0x7F) << shift
 16021  				if b < 0x80 {
 16022  					break
 16023  				}
 16024  			}
 16025  			if msglen < 0 {
 16026  				return ErrInvalidLength
 16027  			}
 16028  			postIndex := iNdEx + msglen
 16029  			if postIndex < 0 {
 16030  				return ErrInvalidLength
 16031  			}
 16032  			if postIndex > l {
 16033  				return io.ErrUnexpectedEOF
 16034  			}
 16035  			if m.Cluster == nil {
 16036  				m.Cluster = &Cluster{}
 16037  			}
 16038  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16039  				return err
 16040  			}
 16041  			iNdEx = postIndex
 16042  		case 2:
 16043  			if wireType != 2 {
 16044  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 16045  			}
 16046  			var stringLen uint64
 16047  			for shift := uint(0); ; shift += 7 {
 16048  				if shift >= 64 {
 16049  					return ErrIntOverflow
 16050  				}
 16051  				if iNdEx >= l {
 16052  					return io.ErrUnexpectedEOF
 16053  				}
 16054  				b := dAtA[iNdEx]
 16055  				iNdEx++
 16056  				stringLen |= uint64(b&0x7F) << shift
 16057  				if b < 0x80 {
 16058  					break
 16059  				}
 16060  			}
 16061  			intStringLen := int(stringLen)
 16062  			if intStringLen < 0 {
 16063  				return ErrInvalidLength
 16064  			}
 16065  			postIndex := iNdEx + intStringLen
 16066  			if postIndex < 0 {
 16067  				return ErrInvalidLength
 16068  			}
 16069  			if postIndex > l {
 16070  				return io.ErrUnexpectedEOF
 16071  			}
 16072  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 16073  			iNdEx = postIndex
 16074  		case 3:
 16075  			if wireType != 2 {
 16076  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 16077  			}
 16078  			var stringLen uint64
 16079  			for shift := uint(0); ; shift += 7 {
 16080  				if shift >= 64 {
 16081  					return ErrIntOverflow
 16082  				}
 16083  				if iNdEx >= l {
 16084  					return io.ErrUnexpectedEOF
 16085  				}
 16086  				b := dAtA[iNdEx]
 16087  				iNdEx++
 16088  				stringLen |= uint64(b&0x7F) << shift
 16089  				if b < 0x80 {
 16090  					break
 16091  				}
 16092  			}
 16093  			intStringLen := int(stringLen)
 16094  			if intStringLen < 0 {
 16095  				return ErrInvalidLength
 16096  			}
 16097  			postIndex := iNdEx + intStringLen
 16098  			if postIndex < 0 {
 16099  				return ErrInvalidLength
 16100  			}
 16101  			if postIndex > l {
 16102  				return io.ErrUnexpectedEOF
 16103  			}
 16104  			m.Shard = string(dAtA[iNdEx:postIndex])
 16105  			iNdEx = postIndex
 16106  		case 4:
 16107  			if wireType != 2 {
 16108  				return fmt.Errorf("proto: wrong wireType = %d for field PromotedPrimary", wireType)
 16109  			}
 16110  			var msglen int
 16111  			for shift := uint(0); ; shift += 7 {
 16112  				if shift >= 64 {
 16113  					return ErrIntOverflow
 16114  				}
 16115  				if iNdEx >= l {
 16116  					return io.ErrUnexpectedEOF
 16117  				}
 16118  				b := dAtA[iNdEx]
 16119  				iNdEx++
 16120  				msglen |= int(b&0x7F) << shift
 16121  				if b < 0x80 {
 16122  					break
 16123  				}
 16124  			}
 16125  			if msglen < 0 {
 16126  				return ErrInvalidLength
 16127  			}
 16128  			postIndex := iNdEx + msglen
 16129  			if postIndex < 0 {
 16130  				return ErrInvalidLength
 16131  			}
 16132  			if postIndex > l {
 16133  				return io.ErrUnexpectedEOF
 16134  			}
 16135  			if m.PromotedPrimary == nil {
 16136  				m.PromotedPrimary = &topodata.TabletAlias{}
 16137  			}
 16138  			if err := m.PromotedPrimary.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16139  				return err
 16140  			}
 16141  			iNdEx = postIndex
 16142  		case 5:
 16143  			if wireType != 2 {
 16144  				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 16145  			}
 16146  			var msglen int
 16147  			for shift := uint(0); ; shift += 7 {
 16148  				if shift >= 64 {
 16149  					return ErrIntOverflow
 16150  				}
 16151  				if iNdEx >= l {
 16152  					return io.ErrUnexpectedEOF
 16153  				}
 16154  				b := dAtA[iNdEx]
 16155  				iNdEx++
 16156  				msglen |= int(b&0x7F) << shift
 16157  				if b < 0x80 {
 16158  					break
 16159  				}
 16160  			}
 16161  			if msglen < 0 {
 16162  				return ErrInvalidLength
 16163  			}
 16164  			postIndex := iNdEx + msglen
 16165  			if postIndex < 0 {
 16166  				return ErrInvalidLength
 16167  			}
 16168  			if postIndex > l {
 16169  				return io.ErrUnexpectedEOF
 16170  			}
 16171  			m.Events = append(m.Events, &logutil.Event{})
 16172  			if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16173  				return err
 16174  			}
 16175  			iNdEx = postIndex
 16176  		default:
 16177  			iNdEx = preIndex
 16178  			skippy, err := skip(dAtA[iNdEx:])
 16179  			if err != nil {
 16180  				return err
 16181  			}
 16182  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16183  				return ErrInvalidLength
 16184  			}
 16185  			if (iNdEx + skippy) > l {
 16186  				return io.ErrUnexpectedEOF
 16187  			}
 16188  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16189  			iNdEx += skippy
 16190  		}
 16191  	}
 16192  
 16193  	if iNdEx > l {
 16194  		return io.ErrUnexpectedEOF
 16195  	}
 16196  	return nil
 16197  }
 16198  func (m *RebuildKeyspaceGraphRequest) UnmarshalVT(dAtA []byte) error {
 16199  	l := len(dAtA)
 16200  	iNdEx := 0
 16201  	for iNdEx < l {
 16202  		preIndex := iNdEx
 16203  		var wire uint64
 16204  		for shift := uint(0); ; shift += 7 {
 16205  			if shift >= 64 {
 16206  				return ErrIntOverflow
 16207  			}
 16208  			if iNdEx >= l {
 16209  				return io.ErrUnexpectedEOF
 16210  			}
 16211  			b := dAtA[iNdEx]
 16212  			iNdEx++
 16213  			wire |= uint64(b&0x7F) << shift
 16214  			if b < 0x80 {
 16215  				break
 16216  			}
 16217  		}
 16218  		fieldNum := int32(wire >> 3)
 16219  		wireType := int(wire & 0x7)
 16220  		if wireType == 4 {
 16221  			return fmt.Errorf("proto: RebuildKeyspaceGraphRequest: wiretype end group for non-group")
 16222  		}
 16223  		if fieldNum <= 0 {
 16224  			return fmt.Errorf("proto: RebuildKeyspaceGraphRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 16225  		}
 16226  		switch fieldNum {
 16227  		case 1:
 16228  			if wireType != 2 {
 16229  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 16230  			}
 16231  			var stringLen uint64
 16232  			for shift := uint(0); ; shift += 7 {
 16233  				if shift >= 64 {
 16234  					return ErrIntOverflow
 16235  				}
 16236  				if iNdEx >= l {
 16237  					return io.ErrUnexpectedEOF
 16238  				}
 16239  				b := dAtA[iNdEx]
 16240  				iNdEx++
 16241  				stringLen |= uint64(b&0x7F) << shift
 16242  				if b < 0x80 {
 16243  					break
 16244  				}
 16245  			}
 16246  			intStringLen := int(stringLen)
 16247  			if intStringLen < 0 {
 16248  				return ErrInvalidLength
 16249  			}
 16250  			postIndex := iNdEx + intStringLen
 16251  			if postIndex < 0 {
 16252  				return ErrInvalidLength
 16253  			}
 16254  			if postIndex > l {
 16255  				return io.ErrUnexpectedEOF
 16256  			}
 16257  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 16258  			iNdEx = postIndex
 16259  		case 2:
 16260  			if wireType != 2 {
 16261  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 16262  			}
 16263  			var stringLen uint64
 16264  			for shift := uint(0); ; shift += 7 {
 16265  				if shift >= 64 {
 16266  					return ErrIntOverflow
 16267  				}
 16268  				if iNdEx >= l {
 16269  					return io.ErrUnexpectedEOF
 16270  				}
 16271  				b := dAtA[iNdEx]
 16272  				iNdEx++
 16273  				stringLen |= uint64(b&0x7F) << shift
 16274  				if b < 0x80 {
 16275  					break
 16276  				}
 16277  			}
 16278  			intStringLen := int(stringLen)
 16279  			if intStringLen < 0 {
 16280  				return ErrInvalidLength
 16281  			}
 16282  			postIndex := iNdEx + intStringLen
 16283  			if postIndex < 0 {
 16284  				return ErrInvalidLength
 16285  			}
 16286  			if postIndex > l {
 16287  				return io.ErrUnexpectedEOF
 16288  			}
 16289  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 16290  			iNdEx = postIndex
 16291  		case 3:
 16292  			if wireType != 2 {
 16293  				return fmt.Errorf("proto: wrong wireType = %d for field Cells", wireType)
 16294  			}
 16295  			var stringLen uint64
 16296  			for shift := uint(0); ; shift += 7 {
 16297  				if shift >= 64 {
 16298  					return ErrIntOverflow
 16299  				}
 16300  				if iNdEx >= l {
 16301  					return io.ErrUnexpectedEOF
 16302  				}
 16303  				b := dAtA[iNdEx]
 16304  				iNdEx++
 16305  				stringLen |= uint64(b&0x7F) << shift
 16306  				if b < 0x80 {
 16307  					break
 16308  				}
 16309  			}
 16310  			intStringLen := int(stringLen)
 16311  			if intStringLen < 0 {
 16312  				return ErrInvalidLength
 16313  			}
 16314  			postIndex := iNdEx + intStringLen
 16315  			if postIndex < 0 {
 16316  				return ErrInvalidLength
 16317  			}
 16318  			if postIndex > l {
 16319  				return io.ErrUnexpectedEOF
 16320  			}
 16321  			m.Cells = append(m.Cells, string(dAtA[iNdEx:postIndex]))
 16322  			iNdEx = postIndex
 16323  		case 4:
 16324  			if wireType != 0 {
 16325  				return fmt.Errorf("proto: wrong wireType = %d for field AllowPartial", wireType)
 16326  			}
 16327  			var v int
 16328  			for shift := uint(0); ; shift += 7 {
 16329  				if shift >= 64 {
 16330  					return ErrIntOverflow
 16331  				}
 16332  				if iNdEx >= l {
 16333  					return io.ErrUnexpectedEOF
 16334  				}
 16335  				b := dAtA[iNdEx]
 16336  				iNdEx++
 16337  				v |= int(b&0x7F) << shift
 16338  				if b < 0x80 {
 16339  					break
 16340  				}
 16341  			}
 16342  			m.AllowPartial = bool(v != 0)
 16343  		default:
 16344  			iNdEx = preIndex
 16345  			skippy, err := skip(dAtA[iNdEx:])
 16346  			if err != nil {
 16347  				return err
 16348  			}
 16349  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16350  				return ErrInvalidLength
 16351  			}
 16352  			if (iNdEx + skippy) > l {
 16353  				return io.ErrUnexpectedEOF
 16354  			}
 16355  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16356  			iNdEx += skippy
 16357  		}
 16358  	}
 16359  
 16360  	if iNdEx > l {
 16361  		return io.ErrUnexpectedEOF
 16362  	}
 16363  	return nil
 16364  }
 16365  func (m *RebuildKeyspaceGraphResponse) UnmarshalVT(dAtA []byte) error {
 16366  	l := len(dAtA)
 16367  	iNdEx := 0
 16368  	for iNdEx < l {
 16369  		preIndex := iNdEx
 16370  		var wire uint64
 16371  		for shift := uint(0); ; shift += 7 {
 16372  			if shift >= 64 {
 16373  				return ErrIntOverflow
 16374  			}
 16375  			if iNdEx >= l {
 16376  				return io.ErrUnexpectedEOF
 16377  			}
 16378  			b := dAtA[iNdEx]
 16379  			iNdEx++
 16380  			wire |= uint64(b&0x7F) << shift
 16381  			if b < 0x80 {
 16382  				break
 16383  			}
 16384  		}
 16385  		fieldNum := int32(wire >> 3)
 16386  		wireType := int(wire & 0x7)
 16387  		if wireType == 4 {
 16388  			return fmt.Errorf("proto: RebuildKeyspaceGraphResponse: wiretype end group for non-group")
 16389  		}
 16390  		if fieldNum <= 0 {
 16391  			return fmt.Errorf("proto: RebuildKeyspaceGraphResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 16392  		}
 16393  		switch fieldNum {
 16394  		case 1:
 16395  			if wireType != 2 {
 16396  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 16397  			}
 16398  			var stringLen uint64
 16399  			for shift := uint(0); ; shift += 7 {
 16400  				if shift >= 64 {
 16401  					return ErrIntOverflow
 16402  				}
 16403  				if iNdEx >= l {
 16404  					return io.ErrUnexpectedEOF
 16405  				}
 16406  				b := dAtA[iNdEx]
 16407  				iNdEx++
 16408  				stringLen |= uint64(b&0x7F) << shift
 16409  				if b < 0x80 {
 16410  					break
 16411  				}
 16412  			}
 16413  			intStringLen := int(stringLen)
 16414  			if intStringLen < 0 {
 16415  				return ErrInvalidLength
 16416  			}
 16417  			postIndex := iNdEx + intStringLen
 16418  			if postIndex < 0 {
 16419  				return ErrInvalidLength
 16420  			}
 16421  			if postIndex > l {
 16422  				return io.ErrUnexpectedEOF
 16423  			}
 16424  			m.Status = string(dAtA[iNdEx:postIndex])
 16425  			iNdEx = postIndex
 16426  		default:
 16427  			iNdEx = preIndex
 16428  			skippy, err := skip(dAtA[iNdEx:])
 16429  			if err != nil {
 16430  				return err
 16431  			}
 16432  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16433  				return ErrInvalidLength
 16434  			}
 16435  			if (iNdEx + skippy) > l {
 16436  				return io.ErrUnexpectedEOF
 16437  			}
 16438  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16439  			iNdEx += skippy
 16440  		}
 16441  	}
 16442  
 16443  	if iNdEx > l {
 16444  		return io.ErrUnexpectedEOF
 16445  	}
 16446  	return nil
 16447  }
 16448  func (m *RefreshStateRequest) UnmarshalVT(dAtA []byte) error {
 16449  	l := len(dAtA)
 16450  	iNdEx := 0
 16451  	for iNdEx < l {
 16452  		preIndex := iNdEx
 16453  		var wire uint64
 16454  		for shift := uint(0); ; shift += 7 {
 16455  			if shift >= 64 {
 16456  				return ErrIntOverflow
 16457  			}
 16458  			if iNdEx >= l {
 16459  				return io.ErrUnexpectedEOF
 16460  			}
 16461  			b := dAtA[iNdEx]
 16462  			iNdEx++
 16463  			wire |= uint64(b&0x7F) << shift
 16464  			if b < 0x80 {
 16465  				break
 16466  			}
 16467  		}
 16468  		fieldNum := int32(wire >> 3)
 16469  		wireType := int(wire & 0x7)
 16470  		if wireType == 4 {
 16471  			return fmt.Errorf("proto: RefreshStateRequest: wiretype end group for non-group")
 16472  		}
 16473  		if fieldNum <= 0 {
 16474  			return fmt.Errorf("proto: RefreshStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 16475  		}
 16476  		switch fieldNum {
 16477  		case 1:
 16478  			if wireType != 2 {
 16479  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 16480  			}
 16481  			var msglen int
 16482  			for shift := uint(0); ; shift += 7 {
 16483  				if shift >= 64 {
 16484  					return ErrIntOverflow
 16485  				}
 16486  				if iNdEx >= l {
 16487  					return io.ErrUnexpectedEOF
 16488  				}
 16489  				b := dAtA[iNdEx]
 16490  				iNdEx++
 16491  				msglen |= int(b&0x7F) << shift
 16492  				if b < 0x80 {
 16493  					break
 16494  				}
 16495  			}
 16496  			if msglen < 0 {
 16497  				return ErrInvalidLength
 16498  			}
 16499  			postIndex := iNdEx + msglen
 16500  			if postIndex < 0 {
 16501  				return ErrInvalidLength
 16502  			}
 16503  			if postIndex > l {
 16504  				return io.ErrUnexpectedEOF
 16505  			}
 16506  			if m.Alias == nil {
 16507  				m.Alias = &topodata.TabletAlias{}
 16508  			}
 16509  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16510  				return err
 16511  			}
 16512  			iNdEx = postIndex
 16513  		case 2:
 16514  			if wireType != 2 {
 16515  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 16516  			}
 16517  			var stringLen uint64
 16518  			for shift := uint(0); ; shift += 7 {
 16519  				if shift >= 64 {
 16520  					return ErrIntOverflow
 16521  				}
 16522  				if iNdEx >= l {
 16523  					return io.ErrUnexpectedEOF
 16524  				}
 16525  				b := dAtA[iNdEx]
 16526  				iNdEx++
 16527  				stringLen |= uint64(b&0x7F) << shift
 16528  				if b < 0x80 {
 16529  					break
 16530  				}
 16531  			}
 16532  			intStringLen := int(stringLen)
 16533  			if intStringLen < 0 {
 16534  				return ErrInvalidLength
 16535  			}
 16536  			postIndex := iNdEx + intStringLen
 16537  			if postIndex < 0 {
 16538  				return ErrInvalidLength
 16539  			}
 16540  			if postIndex > l {
 16541  				return io.ErrUnexpectedEOF
 16542  			}
 16543  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 16544  			iNdEx = postIndex
 16545  		default:
 16546  			iNdEx = preIndex
 16547  			skippy, err := skip(dAtA[iNdEx:])
 16548  			if err != nil {
 16549  				return err
 16550  			}
 16551  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16552  				return ErrInvalidLength
 16553  			}
 16554  			if (iNdEx + skippy) > l {
 16555  				return io.ErrUnexpectedEOF
 16556  			}
 16557  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16558  			iNdEx += skippy
 16559  		}
 16560  	}
 16561  
 16562  	if iNdEx > l {
 16563  		return io.ErrUnexpectedEOF
 16564  	}
 16565  	return nil
 16566  }
 16567  func (m *RefreshStateResponse) UnmarshalVT(dAtA []byte) error {
 16568  	l := len(dAtA)
 16569  	iNdEx := 0
 16570  	for iNdEx < l {
 16571  		preIndex := iNdEx
 16572  		var wire uint64
 16573  		for shift := uint(0); ; shift += 7 {
 16574  			if shift >= 64 {
 16575  				return ErrIntOverflow
 16576  			}
 16577  			if iNdEx >= l {
 16578  				return io.ErrUnexpectedEOF
 16579  			}
 16580  			b := dAtA[iNdEx]
 16581  			iNdEx++
 16582  			wire |= uint64(b&0x7F) << shift
 16583  			if b < 0x80 {
 16584  				break
 16585  			}
 16586  		}
 16587  		fieldNum := int32(wire >> 3)
 16588  		wireType := int(wire & 0x7)
 16589  		if wireType == 4 {
 16590  			return fmt.Errorf("proto: RefreshStateResponse: wiretype end group for non-group")
 16591  		}
 16592  		if fieldNum <= 0 {
 16593  			return fmt.Errorf("proto: RefreshStateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 16594  		}
 16595  		switch fieldNum {
 16596  		case 1:
 16597  			if wireType != 2 {
 16598  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 16599  			}
 16600  			var stringLen uint64
 16601  			for shift := uint(0); ; shift += 7 {
 16602  				if shift >= 64 {
 16603  					return ErrIntOverflow
 16604  				}
 16605  				if iNdEx >= l {
 16606  					return io.ErrUnexpectedEOF
 16607  				}
 16608  				b := dAtA[iNdEx]
 16609  				iNdEx++
 16610  				stringLen |= uint64(b&0x7F) << shift
 16611  				if b < 0x80 {
 16612  					break
 16613  				}
 16614  			}
 16615  			intStringLen := int(stringLen)
 16616  			if intStringLen < 0 {
 16617  				return ErrInvalidLength
 16618  			}
 16619  			postIndex := iNdEx + intStringLen
 16620  			if postIndex < 0 {
 16621  				return ErrInvalidLength
 16622  			}
 16623  			if postIndex > l {
 16624  				return io.ErrUnexpectedEOF
 16625  			}
 16626  			m.Status = string(dAtA[iNdEx:postIndex])
 16627  			iNdEx = postIndex
 16628  		case 2:
 16629  			if wireType != 2 {
 16630  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 16631  			}
 16632  			var msglen int
 16633  			for shift := uint(0); ; shift += 7 {
 16634  				if shift >= 64 {
 16635  					return ErrIntOverflow
 16636  				}
 16637  				if iNdEx >= l {
 16638  					return io.ErrUnexpectedEOF
 16639  				}
 16640  				b := dAtA[iNdEx]
 16641  				iNdEx++
 16642  				msglen |= int(b&0x7F) << shift
 16643  				if b < 0x80 {
 16644  					break
 16645  				}
 16646  			}
 16647  			if msglen < 0 {
 16648  				return ErrInvalidLength
 16649  			}
 16650  			postIndex := iNdEx + msglen
 16651  			if postIndex < 0 {
 16652  				return ErrInvalidLength
 16653  			}
 16654  			if postIndex > l {
 16655  				return io.ErrUnexpectedEOF
 16656  			}
 16657  			if m.Cluster == nil {
 16658  				m.Cluster = &Cluster{}
 16659  			}
 16660  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16661  				return err
 16662  			}
 16663  			iNdEx = postIndex
 16664  		default:
 16665  			iNdEx = preIndex
 16666  			skippy, err := skip(dAtA[iNdEx:])
 16667  			if err != nil {
 16668  				return err
 16669  			}
 16670  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16671  				return ErrInvalidLength
 16672  			}
 16673  			if (iNdEx + skippy) > l {
 16674  				return io.ErrUnexpectedEOF
 16675  			}
 16676  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16677  			iNdEx += skippy
 16678  		}
 16679  	}
 16680  
 16681  	if iNdEx > l {
 16682  		return io.ErrUnexpectedEOF
 16683  	}
 16684  	return nil
 16685  }
 16686  func (m *ReloadSchemasRequest) UnmarshalVT(dAtA []byte) error {
 16687  	l := len(dAtA)
 16688  	iNdEx := 0
 16689  	for iNdEx < l {
 16690  		preIndex := iNdEx
 16691  		var wire uint64
 16692  		for shift := uint(0); ; shift += 7 {
 16693  			if shift >= 64 {
 16694  				return ErrIntOverflow
 16695  			}
 16696  			if iNdEx >= l {
 16697  				return io.ErrUnexpectedEOF
 16698  			}
 16699  			b := dAtA[iNdEx]
 16700  			iNdEx++
 16701  			wire |= uint64(b&0x7F) << shift
 16702  			if b < 0x80 {
 16703  				break
 16704  			}
 16705  		}
 16706  		fieldNum := int32(wire >> 3)
 16707  		wireType := int(wire & 0x7)
 16708  		if wireType == 4 {
 16709  			return fmt.Errorf("proto: ReloadSchemasRequest: wiretype end group for non-group")
 16710  		}
 16711  		if fieldNum <= 0 {
 16712  			return fmt.Errorf("proto: ReloadSchemasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 16713  		}
 16714  		switch fieldNum {
 16715  		case 1:
 16716  			if wireType != 2 {
 16717  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspaces", wireType)
 16718  			}
 16719  			var stringLen uint64
 16720  			for shift := uint(0); ; shift += 7 {
 16721  				if shift >= 64 {
 16722  					return ErrIntOverflow
 16723  				}
 16724  				if iNdEx >= l {
 16725  					return io.ErrUnexpectedEOF
 16726  				}
 16727  				b := dAtA[iNdEx]
 16728  				iNdEx++
 16729  				stringLen |= uint64(b&0x7F) << shift
 16730  				if b < 0x80 {
 16731  					break
 16732  				}
 16733  			}
 16734  			intStringLen := int(stringLen)
 16735  			if intStringLen < 0 {
 16736  				return ErrInvalidLength
 16737  			}
 16738  			postIndex := iNdEx + intStringLen
 16739  			if postIndex < 0 {
 16740  				return ErrInvalidLength
 16741  			}
 16742  			if postIndex > l {
 16743  				return io.ErrUnexpectedEOF
 16744  			}
 16745  			m.Keyspaces = append(m.Keyspaces, string(dAtA[iNdEx:postIndex]))
 16746  			iNdEx = postIndex
 16747  		case 2:
 16748  			if wireType != 2 {
 16749  				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceShards", wireType)
 16750  			}
 16751  			var stringLen uint64
 16752  			for shift := uint(0); ; shift += 7 {
 16753  				if shift >= 64 {
 16754  					return ErrIntOverflow
 16755  				}
 16756  				if iNdEx >= l {
 16757  					return io.ErrUnexpectedEOF
 16758  				}
 16759  				b := dAtA[iNdEx]
 16760  				iNdEx++
 16761  				stringLen |= uint64(b&0x7F) << shift
 16762  				if b < 0x80 {
 16763  					break
 16764  				}
 16765  			}
 16766  			intStringLen := int(stringLen)
 16767  			if intStringLen < 0 {
 16768  				return ErrInvalidLength
 16769  			}
 16770  			postIndex := iNdEx + intStringLen
 16771  			if postIndex < 0 {
 16772  				return ErrInvalidLength
 16773  			}
 16774  			if postIndex > l {
 16775  				return io.ErrUnexpectedEOF
 16776  			}
 16777  			m.KeyspaceShards = append(m.KeyspaceShards, string(dAtA[iNdEx:postIndex]))
 16778  			iNdEx = postIndex
 16779  		case 3:
 16780  			if wireType != 2 {
 16781  				return fmt.Errorf("proto: wrong wireType = %d for field Tablets", wireType)
 16782  			}
 16783  			var msglen int
 16784  			for shift := uint(0); ; shift += 7 {
 16785  				if shift >= 64 {
 16786  					return ErrIntOverflow
 16787  				}
 16788  				if iNdEx >= l {
 16789  					return io.ErrUnexpectedEOF
 16790  				}
 16791  				b := dAtA[iNdEx]
 16792  				iNdEx++
 16793  				msglen |= int(b&0x7F) << shift
 16794  				if b < 0x80 {
 16795  					break
 16796  				}
 16797  			}
 16798  			if msglen < 0 {
 16799  				return ErrInvalidLength
 16800  			}
 16801  			postIndex := iNdEx + msglen
 16802  			if postIndex < 0 {
 16803  				return ErrInvalidLength
 16804  			}
 16805  			if postIndex > l {
 16806  				return io.ErrUnexpectedEOF
 16807  			}
 16808  			m.Tablets = append(m.Tablets, &topodata.TabletAlias{})
 16809  			if err := m.Tablets[len(m.Tablets)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16810  				return err
 16811  			}
 16812  			iNdEx = postIndex
 16813  		case 4:
 16814  			if wireType != 2 {
 16815  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 16816  			}
 16817  			var stringLen uint64
 16818  			for shift := uint(0); ; shift += 7 {
 16819  				if shift >= 64 {
 16820  					return ErrIntOverflow
 16821  				}
 16822  				if iNdEx >= l {
 16823  					return io.ErrUnexpectedEOF
 16824  				}
 16825  				b := dAtA[iNdEx]
 16826  				iNdEx++
 16827  				stringLen |= uint64(b&0x7F) << shift
 16828  				if b < 0x80 {
 16829  					break
 16830  				}
 16831  			}
 16832  			intStringLen := int(stringLen)
 16833  			if intStringLen < 0 {
 16834  				return ErrInvalidLength
 16835  			}
 16836  			postIndex := iNdEx + intStringLen
 16837  			if postIndex < 0 {
 16838  				return ErrInvalidLength
 16839  			}
 16840  			if postIndex > l {
 16841  				return io.ErrUnexpectedEOF
 16842  			}
 16843  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 16844  			iNdEx = postIndex
 16845  		case 5:
 16846  			if wireType != 0 {
 16847  				return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType)
 16848  			}
 16849  			m.Concurrency = 0
 16850  			for shift := uint(0); ; shift += 7 {
 16851  				if shift >= 64 {
 16852  					return ErrIntOverflow
 16853  				}
 16854  				if iNdEx >= l {
 16855  					return io.ErrUnexpectedEOF
 16856  				}
 16857  				b := dAtA[iNdEx]
 16858  				iNdEx++
 16859  				m.Concurrency |= uint32(b&0x7F) << shift
 16860  				if b < 0x80 {
 16861  					break
 16862  				}
 16863  			}
 16864  		case 6:
 16865  			if wireType != 2 {
 16866  				return fmt.Errorf("proto: wrong wireType = %d for field WaitPosition", wireType)
 16867  			}
 16868  			var stringLen uint64
 16869  			for shift := uint(0); ; shift += 7 {
 16870  				if shift >= 64 {
 16871  					return ErrIntOverflow
 16872  				}
 16873  				if iNdEx >= l {
 16874  					return io.ErrUnexpectedEOF
 16875  				}
 16876  				b := dAtA[iNdEx]
 16877  				iNdEx++
 16878  				stringLen |= uint64(b&0x7F) << shift
 16879  				if b < 0x80 {
 16880  					break
 16881  				}
 16882  			}
 16883  			intStringLen := int(stringLen)
 16884  			if intStringLen < 0 {
 16885  				return ErrInvalidLength
 16886  			}
 16887  			postIndex := iNdEx + intStringLen
 16888  			if postIndex < 0 {
 16889  				return ErrInvalidLength
 16890  			}
 16891  			if postIndex > l {
 16892  				return io.ErrUnexpectedEOF
 16893  			}
 16894  			m.WaitPosition = string(dAtA[iNdEx:postIndex])
 16895  			iNdEx = postIndex
 16896  		case 7:
 16897  			if wireType != 0 {
 16898  				return fmt.Errorf("proto: wrong wireType = %d for field IncludePrimary", wireType)
 16899  			}
 16900  			var v int
 16901  			for shift := uint(0); ; shift += 7 {
 16902  				if shift >= 64 {
 16903  					return ErrIntOverflow
 16904  				}
 16905  				if iNdEx >= l {
 16906  					return io.ErrUnexpectedEOF
 16907  				}
 16908  				b := dAtA[iNdEx]
 16909  				iNdEx++
 16910  				v |= int(b&0x7F) << shift
 16911  				if b < 0x80 {
 16912  					break
 16913  				}
 16914  			}
 16915  			m.IncludePrimary = bool(v != 0)
 16916  		default:
 16917  			iNdEx = preIndex
 16918  			skippy, err := skip(dAtA[iNdEx:])
 16919  			if err != nil {
 16920  				return err
 16921  			}
 16922  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16923  				return ErrInvalidLength
 16924  			}
 16925  			if (iNdEx + skippy) > l {
 16926  				return io.ErrUnexpectedEOF
 16927  			}
 16928  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16929  			iNdEx += skippy
 16930  		}
 16931  	}
 16932  
 16933  	if iNdEx > l {
 16934  		return io.ErrUnexpectedEOF
 16935  	}
 16936  	return nil
 16937  }
 16938  func (m *ReloadSchemasResponse_KeyspaceResult) UnmarshalVT(dAtA []byte) error {
 16939  	l := len(dAtA)
 16940  	iNdEx := 0
 16941  	for iNdEx < l {
 16942  		preIndex := iNdEx
 16943  		var wire uint64
 16944  		for shift := uint(0); ; shift += 7 {
 16945  			if shift >= 64 {
 16946  				return ErrIntOverflow
 16947  			}
 16948  			if iNdEx >= l {
 16949  				return io.ErrUnexpectedEOF
 16950  			}
 16951  			b := dAtA[iNdEx]
 16952  			iNdEx++
 16953  			wire |= uint64(b&0x7F) << shift
 16954  			if b < 0x80 {
 16955  				break
 16956  			}
 16957  		}
 16958  		fieldNum := int32(wire >> 3)
 16959  		wireType := int(wire & 0x7)
 16960  		if wireType == 4 {
 16961  			return fmt.Errorf("proto: ReloadSchemasResponse_KeyspaceResult: wiretype end group for non-group")
 16962  		}
 16963  		if fieldNum <= 0 {
 16964  			return fmt.Errorf("proto: ReloadSchemasResponse_KeyspaceResult: illegal tag %d (wire type %d)", fieldNum, wire)
 16965  		}
 16966  		switch fieldNum {
 16967  		case 1:
 16968  			if wireType != 2 {
 16969  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 16970  			}
 16971  			var msglen int
 16972  			for shift := uint(0); ; shift += 7 {
 16973  				if shift >= 64 {
 16974  					return ErrIntOverflow
 16975  				}
 16976  				if iNdEx >= l {
 16977  					return io.ErrUnexpectedEOF
 16978  				}
 16979  				b := dAtA[iNdEx]
 16980  				iNdEx++
 16981  				msglen |= int(b&0x7F) << shift
 16982  				if b < 0x80 {
 16983  					break
 16984  				}
 16985  			}
 16986  			if msglen < 0 {
 16987  				return ErrInvalidLength
 16988  			}
 16989  			postIndex := iNdEx + msglen
 16990  			if postIndex < 0 {
 16991  				return ErrInvalidLength
 16992  			}
 16993  			if postIndex > l {
 16994  				return io.ErrUnexpectedEOF
 16995  			}
 16996  			if m.Keyspace == nil {
 16997  				m.Keyspace = &Keyspace{}
 16998  			}
 16999  			if err := m.Keyspace.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17000  				return err
 17001  			}
 17002  			iNdEx = postIndex
 17003  		case 2:
 17004  			if wireType != 2 {
 17005  				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 17006  			}
 17007  			var msglen int
 17008  			for shift := uint(0); ; shift += 7 {
 17009  				if shift >= 64 {
 17010  					return ErrIntOverflow
 17011  				}
 17012  				if iNdEx >= l {
 17013  					return io.ErrUnexpectedEOF
 17014  				}
 17015  				b := dAtA[iNdEx]
 17016  				iNdEx++
 17017  				msglen |= int(b&0x7F) << shift
 17018  				if b < 0x80 {
 17019  					break
 17020  				}
 17021  			}
 17022  			if msglen < 0 {
 17023  				return ErrInvalidLength
 17024  			}
 17025  			postIndex := iNdEx + msglen
 17026  			if postIndex < 0 {
 17027  				return ErrInvalidLength
 17028  			}
 17029  			if postIndex > l {
 17030  				return io.ErrUnexpectedEOF
 17031  			}
 17032  			m.Events = append(m.Events, &logutil.Event{})
 17033  			if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17034  				return err
 17035  			}
 17036  			iNdEx = postIndex
 17037  		default:
 17038  			iNdEx = preIndex
 17039  			skippy, err := skip(dAtA[iNdEx:])
 17040  			if err != nil {
 17041  				return err
 17042  			}
 17043  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17044  				return ErrInvalidLength
 17045  			}
 17046  			if (iNdEx + skippy) > l {
 17047  				return io.ErrUnexpectedEOF
 17048  			}
 17049  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17050  			iNdEx += skippy
 17051  		}
 17052  	}
 17053  
 17054  	if iNdEx > l {
 17055  		return io.ErrUnexpectedEOF
 17056  	}
 17057  	return nil
 17058  }
 17059  func (m *ReloadSchemasResponse_ShardResult) UnmarshalVT(dAtA []byte) error {
 17060  	l := len(dAtA)
 17061  	iNdEx := 0
 17062  	for iNdEx < l {
 17063  		preIndex := iNdEx
 17064  		var wire uint64
 17065  		for shift := uint(0); ; shift += 7 {
 17066  			if shift >= 64 {
 17067  				return ErrIntOverflow
 17068  			}
 17069  			if iNdEx >= l {
 17070  				return io.ErrUnexpectedEOF
 17071  			}
 17072  			b := dAtA[iNdEx]
 17073  			iNdEx++
 17074  			wire |= uint64(b&0x7F) << shift
 17075  			if b < 0x80 {
 17076  				break
 17077  			}
 17078  		}
 17079  		fieldNum := int32(wire >> 3)
 17080  		wireType := int(wire & 0x7)
 17081  		if wireType == 4 {
 17082  			return fmt.Errorf("proto: ReloadSchemasResponse_ShardResult: wiretype end group for non-group")
 17083  		}
 17084  		if fieldNum <= 0 {
 17085  			return fmt.Errorf("proto: ReloadSchemasResponse_ShardResult: illegal tag %d (wire type %d)", fieldNum, wire)
 17086  		}
 17087  		switch fieldNum {
 17088  		case 1:
 17089  			if wireType != 2 {
 17090  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 17091  			}
 17092  			var msglen int
 17093  			for shift := uint(0); ; shift += 7 {
 17094  				if shift >= 64 {
 17095  					return ErrIntOverflow
 17096  				}
 17097  				if iNdEx >= l {
 17098  					return io.ErrUnexpectedEOF
 17099  				}
 17100  				b := dAtA[iNdEx]
 17101  				iNdEx++
 17102  				msglen |= int(b&0x7F) << shift
 17103  				if b < 0x80 {
 17104  					break
 17105  				}
 17106  			}
 17107  			if msglen < 0 {
 17108  				return ErrInvalidLength
 17109  			}
 17110  			postIndex := iNdEx + msglen
 17111  			if postIndex < 0 {
 17112  				return ErrInvalidLength
 17113  			}
 17114  			if postIndex > l {
 17115  				return io.ErrUnexpectedEOF
 17116  			}
 17117  			if m.Shard == nil {
 17118  				m.Shard = &Shard{}
 17119  			}
 17120  			if err := m.Shard.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17121  				return err
 17122  			}
 17123  			iNdEx = postIndex
 17124  		case 2:
 17125  			if wireType != 2 {
 17126  				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 17127  			}
 17128  			var msglen int
 17129  			for shift := uint(0); ; shift += 7 {
 17130  				if shift >= 64 {
 17131  					return ErrIntOverflow
 17132  				}
 17133  				if iNdEx >= l {
 17134  					return io.ErrUnexpectedEOF
 17135  				}
 17136  				b := dAtA[iNdEx]
 17137  				iNdEx++
 17138  				msglen |= int(b&0x7F) << shift
 17139  				if b < 0x80 {
 17140  					break
 17141  				}
 17142  			}
 17143  			if msglen < 0 {
 17144  				return ErrInvalidLength
 17145  			}
 17146  			postIndex := iNdEx + msglen
 17147  			if postIndex < 0 {
 17148  				return ErrInvalidLength
 17149  			}
 17150  			if postIndex > l {
 17151  				return io.ErrUnexpectedEOF
 17152  			}
 17153  			m.Events = append(m.Events, &logutil.Event{})
 17154  			if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17155  				return err
 17156  			}
 17157  			iNdEx = postIndex
 17158  		default:
 17159  			iNdEx = preIndex
 17160  			skippy, err := skip(dAtA[iNdEx:])
 17161  			if err != nil {
 17162  				return err
 17163  			}
 17164  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17165  				return ErrInvalidLength
 17166  			}
 17167  			if (iNdEx + skippy) > l {
 17168  				return io.ErrUnexpectedEOF
 17169  			}
 17170  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17171  			iNdEx += skippy
 17172  		}
 17173  	}
 17174  
 17175  	if iNdEx > l {
 17176  		return io.ErrUnexpectedEOF
 17177  	}
 17178  	return nil
 17179  }
 17180  func (m *ReloadSchemasResponse_TabletResult) UnmarshalVT(dAtA []byte) error {
 17181  	l := len(dAtA)
 17182  	iNdEx := 0
 17183  	for iNdEx < l {
 17184  		preIndex := iNdEx
 17185  		var wire uint64
 17186  		for shift := uint(0); ; shift += 7 {
 17187  			if shift >= 64 {
 17188  				return ErrIntOverflow
 17189  			}
 17190  			if iNdEx >= l {
 17191  				return io.ErrUnexpectedEOF
 17192  			}
 17193  			b := dAtA[iNdEx]
 17194  			iNdEx++
 17195  			wire |= uint64(b&0x7F) << shift
 17196  			if b < 0x80 {
 17197  				break
 17198  			}
 17199  		}
 17200  		fieldNum := int32(wire >> 3)
 17201  		wireType := int(wire & 0x7)
 17202  		if wireType == 4 {
 17203  			return fmt.Errorf("proto: ReloadSchemasResponse_TabletResult: wiretype end group for non-group")
 17204  		}
 17205  		if fieldNum <= 0 {
 17206  			return fmt.Errorf("proto: ReloadSchemasResponse_TabletResult: illegal tag %d (wire type %d)", fieldNum, wire)
 17207  		}
 17208  		switch fieldNum {
 17209  		case 1:
 17210  			if wireType != 2 {
 17211  				return fmt.Errorf("proto: wrong wireType = %d for field Tablet", wireType)
 17212  			}
 17213  			var msglen int
 17214  			for shift := uint(0); ; shift += 7 {
 17215  				if shift >= 64 {
 17216  					return ErrIntOverflow
 17217  				}
 17218  				if iNdEx >= l {
 17219  					return io.ErrUnexpectedEOF
 17220  				}
 17221  				b := dAtA[iNdEx]
 17222  				iNdEx++
 17223  				msglen |= int(b&0x7F) << shift
 17224  				if b < 0x80 {
 17225  					break
 17226  				}
 17227  			}
 17228  			if msglen < 0 {
 17229  				return ErrInvalidLength
 17230  			}
 17231  			postIndex := iNdEx + msglen
 17232  			if postIndex < 0 {
 17233  				return ErrInvalidLength
 17234  			}
 17235  			if postIndex > l {
 17236  				return io.ErrUnexpectedEOF
 17237  			}
 17238  			if m.Tablet == nil {
 17239  				m.Tablet = &Tablet{}
 17240  			}
 17241  			if err := m.Tablet.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17242  				return err
 17243  			}
 17244  			iNdEx = postIndex
 17245  		case 2:
 17246  			if wireType != 2 {
 17247  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 17248  			}
 17249  			var stringLen uint64
 17250  			for shift := uint(0); ; shift += 7 {
 17251  				if shift >= 64 {
 17252  					return ErrIntOverflow
 17253  				}
 17254  				if iNdEx >= l {
 17255  					return io.ErrUnexpectedEOF
 17256  				}
 17257  				b := dAtA[iNdEx]
 17258  				iNdEx++
 17259  				stringLen |= uint64(b&0x7F) << shift
 17260  				if b < 0x80 {
 17261  					break
 17262  				}
 17263  			}
 17264  			intStringLen := int(stringLen)
 17265  			if intStringLen < 0 {
 17266  				return ErrInvalidLength
 17267  			}
 17268  			postIndex := iNdEx + intStringLen
 17269  			if postIndex < 0 {
 17270  				return ErrInvalidLength
 17271  			}
 17272  			if postIndex > l {
 17273  				return io.ErrUnexpectedEOF
 17274  			}
 17275  			m.Result = string(dAtA[iNdEx:postIndex])
 17276  			iNdEx = postIndex
 17277  		default:
 17278  			iNdEx = preIndex
 17279  			skippy, err := skip(dAtA[iNdEx:])
 17280  			if err != nil {
 17281  				return err
 17282  			}
 17283  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17284  				return ErrInvalidLength
 17285  			}
 17286  			if (iNdEx + skippy) > l {
 17287  				return io.ErrUnexpectedEOF
 17288  			}
 17289  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17290  			iNdEx += skippy
 17291  		}
 17292  	}
 17293  
 17294  	if iNdEx > l {
 17295  		return io.ErrUnexpectedEOF
 17296  	}
 17297  	return nil
 17298  }
 17299  func (m *ReloadSchemasResponse) UnmarshalVT(dAtA []byte) error {
 17300  	l := len(dAtA)
 17301  	iNdEx := 0
 17302  	for iNdEx < l {
 17303  		preIndex := iNdEx
 17304  		var wire uint64
 17305  		for shift := uint(0); ; shift += 7 {
 17306  			if shift >= 64 {
 17307  				return ErrIntOverflow
 17308  			}
 17309  			if iNdEx >= l {
 17310  				return io.ErrUnexpectedEOF
 17311  			}
 17312  			b := dAtA[iNdEx]
 17313  			iNdEx++
 17314  			wire |= uint64(b&0x7F) << shift
 17315  			if b < 0x80 {
 17316  				break
 17317  			}
 17318  		}
 17319  		fieldNum := int32(wire >> 3)
 17320  		wireType := int(wire & 0x7)
 17321  		if wireType == 4 {
 17322  			return fmt.Errorf("proto: ReloadSchemasResponse: wiretype end group for non-group")
 17323  		}
 17324  		if fieldNum <= 0 {
 17325  			return fmt.Errorf("proto: ReloadSchemasResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 17326  		}
 17327  		switch fieldNum {
 17328  		case 1:
 17329  			if wireType != 2 {
 17330  				return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceResults", wireType)
 17331  			}
 17332  			var msglen int
 17333  			for shift := uint(0); ; shift += 7 {
 17334  				if shift >= 64 {
 17335  					return ErrIntOverflow
 17336  				}
 17337  				if iNdEx >= l {
 17338  					return io.ErrUnexpectedEOF
 17339  				}
 17340  				b := dAtA[iNdEx]
 17341  				iNdEx++
 17342  				msglen |= int(b&0x7F) << shift
 17343  				if b < 0x80 {
 17344  					break
 17345  				}
 17346  			}
 17347  			if msglen < 0 {
 17348  				return ErrInvalidLength
 17349  			}
 17350  			postIndex := iNdEx + msglen
 17351  			if postIndex < 0 {
 17352  				return ErrInvalidLength
 17353  			}
 17354  			if postIndex > l {
 17355  				return io.ErrUnexpectedEOF
 17356  			}
 17357  			m.KeyspaceResults = append(m.KeyspaceResults, &ReloadSchemasResponse_KeyspaceResult{})
 17358  			if err := m.KeyspaceResults[len(m.KeyspaceResults)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17359  				return err
 17360  			}
 17361  			iNdEx = postIndex
 17362  		case 2:
 17363  			if wireType != 2 {
 17364  				return fmt.Errorf("proto: wrong wireType = %d for field ShardResults", wireType)
 17365  			}
 17366  			var msglen int
 17367  			for shift := uint(0); ; shift += 7 {
 17368  				if shift >= 64 {
 17369  					return ErrIntOverflow
 17370  				}
 17371  				if iNdEx >= l {
 17372  					return io.ErrUnexpectedEOF
 17373  				}
 17374  				b := dAtA[iNdEx]
 17375  				iNdEx++
 17376  				msglen |= int(b&0x7F) << shift
 17377  				if b < 0x80 {
 17378  					break
 17379  				}
 17380  			}
 17381  			if msglen < 0 {
 17382  				return ErrInvalidLength
 17383  			}
 17384  			postIndex := iNdEx + msglen
 17385  			if postIndex < 0 {
 17386  				return ErrInvalidLength
 17387  			}
 17388  			if postIndex > l {
 17389  				return io.ErrUnexpectedEOF
 17390  			}
 17391  			m.ShardResults = append(m.ShardResults, &ReloadSchemasResponse_ShardResult{})
 17392  			if err := m.ShardResults[len(m.ShardResults)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17393  				return err
 17394  			}
 17395  			iNdEx = postIndex
 17396  		case 3:
 17397  			if wireType != 2 {
 17398  				return fmt.Errorf("proto: wrong wireType = %d for field TabletResults", wireType)
 17399  			}
 17400  			var msglen int
 17401  			for shift := uint(0); ; shift += 7 {
 17402  				if shift >= 64 {
 17403  					return ErrIntOverflow
 17404  				}
 17405  				if iNdEx >= l {
 17406  					return io.ErrUnexpectedEOF
 17407  				}
 17408  				b := dAtA[iNdEx]
 17409  				iNdEx++
 17410  				msglen |= int(b&0x7F) << shift
 17411  				if b < 0x80 {
 17412  					break
 17413  				}
 17414  			}
 17415  			if msglen < 0 {
 17416  				return ErrInvalidLength
 17417  			}
 17418  			postIndex := iNdEx + msglen
 17419  			if postIndex < 0 {
 17420  				return ErrInvalidLength
 17421  			}
 17422  			if postIndex > l {
 17423  				return io.ErrUnexpectedEOF
 17424  			}
 17425  			m.TabletResults = append(m.TabletResults, &ReloadSchemasResponse_TabletResult{})
 17426  			if err := m.TabletResults[len(m.TabletResults)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17427  				return err
 17428  			}
 17429  			iNdEx = postIndex
 17430  		default:
 17431  			iNdEx = preIndex
 17432  			skippy, err := skip(dAtA[iNdEx:])
 17433  			if err != nil {
 17434  				return err
 17435  			}
 17436  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17437  				return ErrInvalidLength
 17438  			}
 17439  			if (iNdEx + skippy) > l {
 17440  				return io.ErrUnexpectedEOF
 17441  			}
 17442  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17443  			iNdEx += skippy
 17444  		}
 17445  	}
 17446  
 17447  	if iNdEx > l {
 17448  		return io.ErrUnexpectedEOF
 17449  	}
 17450  	return nil
 17451  }
 17452  func (m *ReloadSchemaShardRequest) UnmarshalVT(dAtA []byte) error {
 17453  	l := len(dAtA)
 17454  	iNdEx := 0
 17455  	for iNdEx < l {
 17456  		preIndex := iNdEx
 17457  		var wire uint64
 17458  		for shift := uint(0); ; shift += 7 {
 17459  			if shift >= 64 {
 17460  				return ErrIntOverflow
 17461  			}
 17462  			if iNdEx >= l {
 17463  				return io.ErrUnexpectedEOF
 17464  			}
 17465  			b := dAtA[iNdEx]
 17466  			iNdEx++
 17467  			wire |= uint64(b&0x7F) << shift
 17468  			if b < 0x80 {
 17469  				break
 17470  			}
 17471  		}
 17472  		fieldNum := int32(wire >> 3)
 17473  		wireType := int(wire & 0x7)
 17474  		if wireType == 4 {
 17475  			return fmt.Errorf("proto: ReloadSchemaShardRequest: wiretype end group for non-group")
 17476  		}
 17477  		if fieldNum <= 0 {
 17478  			return fmt.Errorf("proto: ReloadSchemaShardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 17479  		}
 17480  		switch fieldNum {
 17481  		case 1:
 17482  			if wireType != 2 {
 17483  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 17484  			}
 17485  			var stringLen uint64
 17486  			for shift := uint(0); ; shift += 7 {
 17487  				if shift >= 64 {
 17488  					return ErrIntOverflow
 17489  				}
 17490  				if iNdEx >= l {
 17491  					return io.ErrUnexpectedEOF
 17492  				}
 17493  				b := dAtA[iNdEx]
 17494  				iNdEx++
 17495  				stringLen |= uint64(b&0x7F) << shift
 17496  				if b < 0x80 {
 17497  					break
 17498  				}
 17499  			}
 17500  			intStringLen := int(stringLen)
 17501  			if intStringLen < 0 {
 17502  				return ErrInvalidLength
 17503  			}
 17504  			postIndex := iNdEx + intStringLen
 17505  			if postIndex < 0 {
 17506  				return ErrInvalidLength
 17507  			}
 17508  			if postIndex > l {
 17509  				return io.ErrUnexpectedEOF
 17510  			}
 17511  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 17512  			iNdEx = postIndex
 17513  		case 2:
 17514  			if wireType != 2 {
 17515  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 17516  			}
 17517  			var stringLen uint64
 17518  			for shift := uint(0); ; shift += 7 {
 17519  				if shift >= 64 {
 17520  					return ErrIntOverflow
 17521  				}
 17522  				if iNdEx >= l {
 17523  					return io.ErrUnexpectedEOF
 17524  				}
 17525  				b := dAtA[iNdEx]
 17526  				iNdEx++
 17527  				stringLen |= uint64(b&0x7F) << shift
 17528  				if b < 0x80 {
 17529  					break
 17530  				}
 17531  			}
 17532  			intStringLen := int(stringLen)
 17533  			if intStringLen < 0 {
 17534  				return ErrInvalidLength
 17535  			}
 17536  			postIndex := iNdEx + intStringLen
 17537  			if postIndex < 0 {
 17538  				return ErrInvalidLength
 17539  			}
 17540  			if postIndex > l {
 17541  				return io.ErrUnexpectedEOF
 17542  			}
 17543  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 17544  			iNdEx = postIndex
 17545  		case 3:
 17546  			if wireType != 2 {
 17547  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 17548  			}
 17549  			var stringLen uint64
 17550  			for shift := uint(0); ; shift += 7 {
 17551  				if shift >= 64 {
 17552  					return ErrIntOverflow
 17553  				}
 17554  				if iNdEx >= l {
 17555  					return io.ErrUnexpectedEOF
 17556  				}
 17557  				b := dAtA[iNdEx]
 17558  				iNdEx++
 17559  				stringLen |= uint64(b&0x7F) << shift
 17560  				if b < 0x80 {
 17561  					break
 17562  				}
 17563  			}
 17564  			intStringLen := int(stringLen)
 17565  			if intStringLen < 0 {
 17566  				return ErrInvalidLength
 17567  			}
 17568  			postIndex := iNdEx + intStringLen
 17569  			if postIndex < 0 {
 17570  				return ErrInvalidLength
 17571  			}
 17572  			if postIndex > l {
 17573  				return io.ErrUnexpectedEOF
 17574  			}
 17575  			m.Shard = string(dAtA[iNdEx:postIndex])
 17576  			iNdEx = postIndex
 17577  		case 4:
 17578  			if wireType != 2 {
 17579  				return fmt.Errorf("proto: wrong wireType = %d for field WaitPosition", wireType)
 17580  			}
 17581  			var stringLen uint64
 17582  			for shift := uint(0); ; shift += 7 {
 17583  				if shift >= 64 {
 17584  					return ErrIntOverflow
 17585  				}
 17586  				if iNdEx >= l {
 17587  					return io.ErrUnexpectedEOF
 17588  				}
 17589  				b := dAtA[iNdEx]
 17590  				iNdEx++
 17591  				stringLen |= uint64(b&0x7F) << shift
 17592  				if b < 0x80 {
 17593  					break
 17594  				}
 17595  			}
 17596  			intStringLen := int(stringLen)
 17597  			if intStringLen < 0 {
 17598  				return ErrInvalidLength
 17599  			}
 17600  			postIndex := iNdEx + intStringLen
 17601  			if postIndex < 0 {
 17602  				return ErrInvalidLength
 17603  			}
 17604  			if postIndex > l {
 17605  				return io.ErrUnexpectedEOF
 17606  			}
 17607  			m.WaitPosition = string(dAtA[iNdEx:postIndex])
 17608  			iNdEx = postIndex
 17609  		case 5:
 17610  			if wireType != 0 {
 17611  				return fmt.Errorf("proto: wrong wireType = %d for field IncludePrimary", wireType)
 17612  			}
 17613  			var v int
 17614  			for shift := uint(0); ; shift += 7 {
 17615  				if shift >= 64 {
 17616  					return ErrIntOverflow
 17617  				}
 17618  				if iNdEx >= l {
 17619  					return io.ErrUnexpectedEOF
 17620  				}
 17621  				b := dAtA[iNdEx]
 17622  				iNdEx++
 17623  				v |= int(b&0x7F) << shift
 17624  				if b < 0x80 {
 17625  					break
 17626  				}
 17627  			}
 17628  			m.IncludePrimary = bool(v != 0)
 17629  		case 6:
 17630  			if wireType != 0 {
 17631  				return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType)
 17632  			}
 17633  			m.Concurrency = 0
 17634  			for shift := uint(0); ; shift += 7 {
 17635  				if shift >= 64 {
 17636  					return ErrIntOverflow
 17637  				}
 17638  				if iNdEx >= l {
 17639  					return io.ErrUnexpectedEOF
 17640  				}
 17641  				b := dAtA[iNdEx]
 17642  				iNdEx++
 17643  				m.Concurrency |= uint32(b&0x7F) << shift
 17644  				if b < 0x80 {
 17645  					break
 17646  				}
 17647  			}
 17648  		default:
 17649  			iNdEx = preIndex
 17650  			skippy, err := skip(dAtA[iNdEx:])
 17651  			if err != nil {
 17652  				return err
 17653  			}
 17654  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17655  				return ErrInvalidLength
 17656  			}
 17657  			if (iNdEx + skippy) > l {
 17658  				return io.ErrUnexpectedEOF
 17659  			}
 17660  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17661  			iNdEx += skippy
 17662  		}
 17663  	}
 17664  
 17665  	if iNdEx > l {
 17666  		return io.ErrUnexpectedEOF
 17667  	}
 17668  	return nil
 17669  }
 17670  func (m *ReloadSchemaShardResponse) UnmarshalVT(dAtA []byte) error {
 17671  	l := len(dAtA)
 17672  	iNdEx := 0
 17673  	for iNdEx < l {
 17674  		preIndex := iNdEx
 17675  		var wire uint64
 17676  		for shift := uint(0); ; shift += 7 {
 17677  			if shift >= 64 {
 17678  				return ErrIntOverflow
 17679  			}
 17680  			if iNdEx >= l {
 17681  				return io.ErrUnexpectedEOF
 17682  			}
 17683  			b := dAtA[iNdEx]
 17684  			iNdEx++
 17685  			wire |= uint64(b&0x7F) << shift
 17686  			if b < 0x80 {
 17687  				break
 17688  			}
 17689  		}
 17690  		fieldNum := int32(wire >> 3)
 17691  		wireType := int(wire & 0x7)
 17692  		if wireType == 4 {
 17693  			return fmt.Errorf("proto: ReloadSchemaShardResponse: wiretype end group for non-group")
 17694  		}
 17695  		if fieldNum <= 0 {
 17696  			return fmt.Errorf("proto: ReloadSchemaShardResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 17697  		}
 17698  		switch fieldNum {
 17699  		case 1:
 17700  			if wireType != 2 {
 17701  				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
 17702  			}
 17703  			var msglen int
 17704  			for shift := uint(0); ; shift += 7 {
 17705  				if shift >= 64 {
 17706  					return ErrIntOverflow
 17707  				}
 17708  				if iNdEx >= l {
 17709  					return io.ErrUnexpectedEOF
 17710  				}
 17711  				b := dAtA[iNdEx]
 17712  				iNdEx++
 17713  				msglen |= int(b&0x7F) << shift
 17714  				if b < 0x80 {
 17715  					break
 17716  				}
 17717  			}
 17718  			if msglen < 0 {
 17719  				return ErrInvalidLength
 17720  			}
 17721  			postIndex := iNdEx + msglen
 17722  			if postIndex < 0 {
 17723  				return ErrInvalidLength
 17724  			}
 17725  			if postIndex > l {
 17726  				return io.ErrUnexpectedEOF
 17727  			}
 17728  			m.Events = append(m.Events, &logutil.Event{})
 17729  			if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17730  				return err
 17731  			}
 17732  			iNdEx = postIndex
 17733  		default:
 17734  			iNdEx = preIndex
 17735  			skippy, err := skip(dAtA[iNdEx:])
 17736  			if err != nil {
 17737  				return err
 17738  			}
 17739  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17740  				return ErrInvalidLength
 17741  			}
 17742  			if (iNdEx + skippy) > l {
 17743  				return io.ErrUnexpectedEOF
 17744  			}
 17745  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17746  			iNdEx += skippy
 17747  		}
 17748  	}
 17749  
 17750  	if iNdEx > l {
 17751  		return io.ErrUnexpectedEOF
 17752  	}
 17753  	return nil
 17754  }
 17755  func (m *RefreshTabletReplicationSourceRequest) UnmarshalVT(dAtA []byte) error {
 17756  	l := len(dAtA)
 17757  	iNdEx := 0
 17758  	for iNdEx < l {
 17759  		preIndex := iNdEx
 17760  		var wire uint64
 17761  		for shift := uint(0); ; shift += 7 {
 17762  			if shift >= 64 {
 17763  				return ErrIntOverflow
 17764  			}
 17765  			if iNdEx >= l {
 17766  				return io.ErrUnexpectedEOF
 17767  			}
 17768  			b := dAtA[iNdEx]
 17769  			iNdEx++
 17770  			wire |= uint64(b&0x7F) << shift
 17771  			if b < 0x80 {
 17772  				break
 17773  			}
 17774  		}
 17775  		fieldNum := int32(wire >> 3)
 17776  		wireType := int(wire & 0x7)
 17777  		if wireType == 4 {
 17778  			return fmt.Errorf("proto: RefreshTabletReplicationSourceRequest: wiretype end group for non-group")
 17779  		}
 17780  		if fieldNum <= 0 {
 17781  			return fmt.Errorf("proto: RefreshTabletReplicationSourceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 17782  		}
 17783  		switch fieldNum {
 17784  		case 1:
 17785  			if wireType != 2 {
 17786  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 17787  			}
 17788  			var msglen int
 17789  			for shift := uint(0); ; shift += 7 {
 17790  				if shift >= 64 {
 17791  					return ErrIntOverflow
 17792  				}
 17793  				if iNdEx >= l {
 17794  					return io.ErrUnexpectedEOF
 17795  				}
 17796  				b := dAtA[iNdEx]
 17797  				iNdEx++
 17798  				msglen |= int(b&0x7F) << shift
 17799  				if b < 0x80 {
 17800  					break
 17801  				}
 17802  			}
 17803  			if msglen < 0 {
 17804  				return ErrInvalidLength
 17805  			}
 17806  			postIndex := iNdEx + msglen
 17807  			if postIndex < 0 {
 17808  				return ErrInvalidLength
 17809  			}
 17810  			if postIndex > l {
 17811  				return io.ErrUnexpectedEOF
 17812  			}
 17813  			if m.Alias == nil {
 17814  				m.Alias = &topodata.TabletAlias{}
 17815  			}
 17816  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 17817  				return err
 17818  			}
 17819  			iNdEx = postIndex
 17820  		case 2:
 17821  			if wireType != 2 {
 17822  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 17823  			}
 17824  			var stringLen uint64
 17825  			for shift := uint(0); ; shift += 7 {
 17826  				if shift >= 64 {
 17827  					return ErrIntOverflow
 17828  				}
 17829  				if iNdEx >= l {
 17830  					return io.ErrUnexpectedEOF
 17831  				}
 17832  				b := dAtA[iNdEx]
 17833  				iNdEx++
 17834  				stringLen |= uint64(b&0x7F) << shift
 17835  				if b < 0x80 {
 17836  					break
 17837  				}
 17838  			}
 17839  			intStringLen := int(stringLen)
 17840  			if intStringLen < 0 {
 17841  				return ErrInvalidLength
 17842  			}
 17843  			postIndex := iNdEx + intStringLen
 17844  			if postIndex < 0 {
 17845  				return ErrInvalidLength
 17846  			}
 17847  			if postIndex > l {
 17848  				return io.ErrUnexpectedEOF
 17849  			}
 17850  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 17851  			iNdEx = postIndex
 17852  		default:
 17853  			iNdEx = preIndex
 17854  			skippy, err := skip(dAtA[iNdEx:])
 17855  			if err != nil {
 17856  				return err
 17857  			}
 17858  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 17859  				return ErrInvalidLength
 17860  			}
 17861  			if (iNdEx + skippy) > l {
 17862  				return io.ErrUnexpectedEOF
 17863  			}
 17864  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 17865  			iNdEx += skippy
 17866  		}
 17867  	}
 17868  
 17869  	if iNdEx > l {
 17870  		return io.ErrUnexpectedEOF
 17871  	}
 17872  	return nil
 17873  }
 17874  func (m *RefreshTabletReplicationSourceResponse) UnmarshalVT(dAtA []byte) error {
 17875  	l := len(dAtA)
 17876  	iNdEx := 0
 17877  	for iNdEx < l {
 17878  		preIndex := iNdEx
 17879  		var wire uint64
 17880  		for shift := uint(0); ; shift += 7 {
 17881  			if shift >= 64 {
 17882  				return ErrIntOverflow
 17883  			}
 17884  			if iNdEx >= l {
 17885  				return io.ErrUnexpectedEOF
 17886  			}
 17887  			b := dAtA[iNdEx]
 17888  			iNdEx++
 17889  			wire |= uint64(b&0x7F) << shift
 17890  			if b < 0x80 {
 17891  				break
 17892  			}
 17893  		}
 17894  		fieldNum := int32(wire >> 3)
 17895  		wireType := int(wire & 0x7)
 17896  		if wireType == 4 {
 17897  			return fmt.Errorf("proto: RefreshTabletReplicationSourceResponse: wiretype end group for non-group")
 17898  		}
 17899  		if fieldNum <= 0 {
 17900  			return fmt.Errorf("proto: RefreshTabletReplicationSourceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 17901  		}
 17902  		switch fieldNum {
 17903  		case 1:
 17904  			if wireType != 2 {
 17905  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 17906  			}
 17907  			var stringLen uint64
 17908  			for shift := uint(0); ; shift += 7 {
 17909  				if shift >= 64 {
 17910  					return ErrIntOverflow
 17911  				}
 17912  				if iNdEx >= l {
 17913  					return io.ErrUnexpectedEOF
 17914  				}
 17915  				b := dAtA[iNdEx]
 17916  				iNdEx++
 17917  				stringLen |= uint64(b&0x7F) << shift
 17918  				if b < 0x80 {
 17919  					break
 17920  				}
 17921  			}
 17922  			intStringLen := int(stringLen)
 17923  			if intStringLen < 0 {
 17924  				return ErrInvalidLength
 17925  			}
 17926  			postIndex := iNdEx + intStringLen
 17927  			if postIndex < 0 {
 17928  				return ErrInvalidLength
 17929  			}
 17930  			if postIndex > l {
 17931  				return io.ErrUnexpectedEOF
 17932  			}
 17933  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 17934  			iNdEx = postIndex
 17935  		case 2:
 17936  			if wireType != 2 {
 17937  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 17938  			}
 17939  			var stringLen uint64
 17940  			for shift := uint(0); ; shift += 7 {
 17941  				if shift >= 64 {
 17942  					return ErrIntOverflow
 17943  				}
 17944  				if iNdEx >= l {
 17945  					return io.ErrUnexpectedEOF
 17946  				}
 17947  				b := dAtA[iNdEx]
 17948  				iNdEx++
 17949  				stringLen |= uint64(b&0x7F) << shift
 17950  				if b < 0x80 {
 17951  					break
 17952  				}
 17953  			}
 17954  			intStringLen := int(stringLen)
 17955  			if intStringLen < 0 {
 17956  				return ErrInvalidLength
 17957  			}
 17958  			postIndex := iNdEx + intStringLen
 17959  			if postIndex < 0 {
 17960  				return ErrInvalidLength
 17961  			}
 17962  			if postIndex > l {
 17963  				return io.ErrUnexpectedEOF
 17964  			}
 17965  			m.Shard = string(dAtA[iNdEx:postIndex])
 17966  			iNdEx = postIndex
 17967  		case 3:
 17968  			if wireType != 2 {
 17969  				return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType)
 17970  			}
 17971  			var msglen int
 17972  			for shift := uint(0); ; shift += 7 {
 17973  				if shift >= 64 {
 17974  					return ErrIntOverflow
 17975  				}
 17976  				if iNdEx >= l {
 17977  					return io.ErrUnexpectedEOF
 17978  				}
 17979  				b := dAtA[iNdEx]
 17980  				iNdEx++
 17981  				msglen |= int(b&0x7F) << shift
 17982  				if b < 0x80 {
 17983  					break
 17984  				}
 17985  			}
 17986  			if msglen < 0 {
 17987  				return ErrInvalidLength
 17988  			}
 17989  			postIndex := iNdEx + msglen
 17990  			if postIndex < 0 {
 17991  				return ErrInvalidLength
 17992  			}
 17993  			if postIndex > l {
 17994  				return io.ErrUnexpectedEOF
 17995  			}
 17996  			if m.Primary == nil {
 17997  				m.Primary = &topodata.TabletAlias{}
 17998  			}
 17999  			if err := m.Primary.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18000  				return err
 18001  			}
 18002  			iNdEx = postIndex
 18003  		case 4:
 18004  			if wireType != 2 {
 18005  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 18006  			}
 18007  			var msglen int
 18008  			for shift := uint(0); ; shift += 7 {
 18009  				if shift >= 64 {
 18010  					return ErrIntOverflow
 18011  				}
 18012  				if iNdEx >= l {
 18013  					return io.ErrUnexpectedEOF
 18014  				}
 18015  				b := dAtA[iNdEx]
 18016  				iNdEx++
 18017  				msglen |= int(b&0x7F) << shift
 18018  				if b < 0x80 {
 18019  					break
 18020  				}
 18021  			}
 18022  			if msglen < 0 {
 18023  				return ErrInvalidLength
 18024  			}
 18025  			postIndex := iNdEx + msglen
 18026  			if postIndex < 0 {
 18027  				return ErrInvalidLength
 18028  			}
 18029  			if postIndex > l {
 18030  				return io.ErrUnexpectedEOF
 18031  			}
 18032  			if m.Cluster == nil {
 18033  				m.Cluster = &Cluster{}
 18034  			}
 18035  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18036  				return err
 18037  			}
 18038  			iNdEx = postIndex
 18039  		default:
 18040  			iNdEx = preIndex
 18041  			skippy, err := skip(dAtA[iNdEx:])
 18042  			if err != nil {
 18043  				return err
 18044  			}
 18045  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18046  				return ErrInvalidLength
 18047  			}
 18048  			if (iNdEx + skippy) > l {
 18049  				return io.ErrUnexpectedEOF
 18050  			}
 18051  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18052  			iNdEx += skippy
 18053  		}
 18054  	}
 18055  
 18056  	if iNdEx > l {
 18057  		return io.ErrUnexpectedEOF
 18058  	}
 18059  	return nil
 18060  }
 18061  func (m *RemoveKeyspaceCellRequest) UnmarshalVT(dAtA []byte) error {
 18062  	l := len(dAtA)
 18063  	iNdEx := 0
 18064  	for iNdEx < l {
 18065  		preIndex := iNdEx
 18066  		var wire uint64
 18067  		for shift := uint(0); ; shift += 7 {
 18068  			if shift >= 64 {
 18069  				return ErrIntOverflow
 18070  			}
 18071  			if iNdEx >= l {
 18072  				return io.ErrUnexpectedEOF
 18073  			}
 18074  			b := dAtA[iNdEx]
 18075  			iNdEx++
 18076  			wire |= uint64(b&0x7F) << shift
 18077  			if b < 0x80 {
 18078  				break
 18079  			}
 18080  		}
 18081  		fieldNum := int32(wire >> 3)
 18082  		wireType := int(wire & 0x7)
 18083  		if wireType == 4 {
 18084  			return fmt.Errorf("proto: RemoveKeyspaceCellRequest: wiretype end group for non-group")
 18085  		}
 18086  		if fieldNum <= 0 {
 18087  			return fmt.Errorf("proto: RemoveKeyspaceCellRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 18088  		}
 18089  		switch fieldNum {
 18090  		case 1:
 18091  			if wireType != 2 {
 18092  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 18093  			}
 18094  			var stringLen uint64
 18095  			for shift := uint(0); ; shift += 7 {
 18096  				if shift >= 64 {
 18097  					return ErrIntOverflow
 18098  				}
 18099  				if iNdEx >= l {
 18100  					return io.ErrUnexpectedEOF
 18101  				}
 18102  				b := dAtA[iNdEx]
 18103  				iNdEx++
 18104  				stringLen |= uint64(b&0x7F) << shift
 18105  				if b < 0x80 {
 18106  					break
 18107  				}
 18108  			}
 18109  			intStringLen := int(stringLen)
 18110  			if intStringLen < 0 {
 18111  				return ErrInvalidLength
 18112  			}
 18113  			postIndex := iNdEx + intStringLen
 18114  			if postIndex < 0 {
 18115  				return ErrInvalidLength
 18116  			}
 18117  			if postIndex > l {
 18118  				return io.ErrUnexpectedEOF
 18119  			}
 18120  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 18121  			iNdEx = postIndex
 18122  		case 2:
 18123  			if wireType != 2 {
 18124  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 18125  			}
 18126  			var stringLen uint64
 18127  			for shift := uint(0); ; shift += 7 {
 18128  				if shift >= 64 {
 18129  					return ErrIntOverflow
 18130  				}
 18131  				if iNdEx >= l {
 18132  					return io.ErrUnexpectedEOF
 18133  				}
 18134  				b := dAtA[iNdEx]
 18135  				iNdEx++
 18136  				stringLen |= uint64(b&0x7F) << shift
 18137  				if b < 0x80 {
 18138  					break
 18139  				}
 18140  			}
 18141  			intStringLen := int(stringLen)
 18142  			if intStringLen < 0 {
 18143  				return ErrInvalidLength
 18144  			}
 18145  			postIndex := iNdEx + intStringLen
 18146  			if postIndex < 0 {
 18147  				return ErrInvalidLength
 18148  			}
 18149  			if postIndex > l {
 18150  				return io.ErrUnexpectedEOF
 18151  			}
 18152  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 18153  			iNdEx = postIndex
 18154  		case 3:
 18155  			if wireType != 2 {
 18156  				return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType)
 18157  			}
 18158  			var stringLen uint64
 18159  			for shift := uint(0); ; shift += 7 {
 18160  				if shift >= 64 {
 18161  					return ErrIntOverflow
 18162  				}
 18163  				if iNdEx >= l {
 18164  					return io.ErrUnexpectedEOF
 18165  				}
 18166  				b := dAtA[iNdEx]
 18167  				iNdEx++
 18168  				stringLen |= uint64(b&0x7F) << shift
 18169  				if b < 0x80 {
 18170  					break
 18171  				}
 18172  			}
 18173  			intStringLen := int(stringLen)
 18174  			if intStringLen < 0 {
 18175  				return ErrInvalidLength
 18176  			}
 18177  			postIndex := iNdEx + intStringLen
 18178  			if postIndex < 0 {
 18179  				return ErrInvalidLength
 18180  			}
 18181  			if postIndex > l {
 18182  				return io.ErrUnexpectedEOF
 18183  			}
 18184  			m.Cell = string(dAtA[iNdEx:postIndex])
 18185  			iNdEx = postIndex
 18186  		case 4:
 18187  			if wireType != 0 {
 18188  				return fmt.Errorf("proto: wrong wireType = %d for field Force", wireType)
 18189  			}
 18190  			var v int
 18191  			for shift := uint(0); ; shift += 7 {
 18192  				if shift >= 64 {
 18193  					return ErrIntOverflow
 18194  				}
 18195  				if iNdEx >= l {
 18196  					return io.ErrUnexpectedEOF
 18197  				}
 18198  				b := dAtA[iNdEx]
 18199  				iNdEx++
 18200  				v |= int(b&0x7F) << shift
 18201  				if b < 0x80 {
 18202  					break
 18203  				}
 18204  			}
 18205  			m.Force = bool(v != 0)
 18206  		case 5:
 18207  			if wireType != 0 {
 18208  				return fmt.Errorf("proto: wrong wireType = %d for field Recursive", wireType)
 18209  			}
 18210  			var v int
 18211  			for shift := uint(0); ; shift += 7 {
 18212  				if shift >= 64 {
 18213  					return ErrIntOverflow
 18214  				}
 18215  				if iNdEx >= l {
 18216  					return io.ErrUnexpectedEOF
 18217  				}
 18218  				b := dAtA[iNdEx]
 18219  				iNdEx++
 18220  				v |= int(b&0x7F) << shift
 18221  				if b < 0x80 {
 18222  					break
 18223  				}
 18224  			}
 18225  			m.Recursive = bool(v != 0)
 18226  		default:
 18227  			iNdEx = preIndex
 18228  			skippy, err := skip(dAtA[iNdEx:])
 18229  			if err != nil {
 18230  				return err
 18231  			}
 18232  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18233  				return ErrInvalidLength
 18234  			}
 18235  			if (iNdEx + skippy) > l {
 18236  				return io.ErrUnexpectedEOF
 18237  			}
 18238  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18239  			iNdEx += skippy
 18240  		}
 18241  	}
 18242  
 18243  	if iNdEx > l {
 18244  		return io.ErrUnexpectedEOF
 18245  	}
 18246  	return nil
 18247  }
 18248  func (m *RemoveKeyspaceCellResponse) UnmarshalVT(dAtA []byte) error {
 18249  	l := len(dAtA)
 18250  	iNdEx := 0
 18251  	for iNdEx < l {
 18252  		preIndex := iNdEx
 18253  		var wire uint64
 18254  		for shift := uint(0); ; shift += 7 {
 18255  			if shift >= 64 {
 18256  				return ErrIntOverflow
 18257  			}
 18258  			if iNdEx >= l {
 18259  				return io.ErrUnexpectedEOF
 18260  			}
 18261  			b := dAtA[iNdEx]
 18262  			iNdEx++
 18263  			wire |= uint64(b&0x7F) << shift
 18264  			if b < 0x80 {
 18265  				break
 18266  			}
 18267  		}
 18268  		fieldNum := int32(wire >> 3)
 18269  		wireType := int(wire & 0x7)
 18270  		if wireType == 4 {
 18271  			return fmt.Errorf("proto: RemoveKeyspaceCellResponse: wiretype end group for non-group")
 18272  		}
 18273  		if fieldNum <= 0 {
 18274  			return fmt.Errorf("proto: RemoveKeyspaceCellResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 18275  		}
 18276  		switch fieldNum {
 18277  		case 1:
 18278  			if wireType != 2 {
 18279  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 18280  			}
 18281  			var stringLen uint64
 18282  			for shift := uint(0); ; shift += 7 {
 18283  				if shift >= 64 {
 18284  					return ErrIntOverflow
 18285  				}
 18286  				if iNdEx >= l {
 18287  					return io.ErrUnexpectedEOF
 18288  				}
 18289  				b := dAtA[iNdEx]
 18290  				iNdEx++
 18291  				stringLen |= uint64(b&0x7F) << shift
 18292  				if b < 0x80 {
 18293  					break
 18294  				}
 18295  			}
 18296  			intStringLen := int(stringLen)
 18297  			if intStringLen < 0 {
 18298  				return ErrInvalidLength
 18299  			}
 18300  			postIndex := iNdEx + intStringLen
 18301  			if postIndex < 0 {
 18302  				return ErrInvalidLength
 18303  			}
 18304  			if postIndex > l {
 18305  				return io.ErrUnexpectedEOF
 18306  			}
 18307  			m.Status = string(dAtA[iNdEx:postIndex])
 18308  			iNdEx = postIndex
 18309  		default:
 18310  			iNdEx = preIndex
 18311  			skippy, err := skip(dAtA[iNdEx:])
 18312  			if err != nil {
 18313  				return err
 18314  			}
 18315  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18316  				return ErrInvalidLength
 18317  			}
 18318  			if (iNdEx + skippy) > l {
 18319  				return io.ErrUnexpectedEOF
 18320  			}
 18321  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18322  			iNdEx += skippy
 18323  		}
 18324  	}
 18325  
 18326  	if iNdEx > l {
 18327  		return io.ErrUnexpectedEOF
 18328  	}
 18329  	return nil
 18330  }
 18331  func (m *RunHealthCheckRequest) UnmarshalVT(dAtA []byte) error {
 18332  	l := len(dAtA)
 18333  	iNdEx := 0
 18334  	for iNdEx < l {
 18335  		preIndex := iNdEx
 18336  		var wire uint64
 18337  		for shift := uint(0); ; shift += 7 {
 18338  			if shift >= 64 {
 18339  				return ErrIntOverflow
 18340  			}
 18341  			if iNdEx >= l {
 18342  				return io.ErrUnexpectedEOF
 18343  			}
 18344  			b := dAtA[iNdEx]
 18345  			iNdEx++
 18346  			wire |= uint64(b&0x7F) << shift
 18347  			if b < 0x80 {
 18348  				break
 18349  			}
 18350  		}
 18351  		fieldNum := int32(wire >> 3)
 18352  		wireType := int(wire & 0x7)
 18353  		if wireType == 4 {
 18354  			return fmt.Errorf("proto: RunHealthCheckRequest: wiretype end group for non-group")
 18355  		}
 18356  		if fieldNum <= 0 {
 18357  			return fmt.Errorf("proto: RunHealthCheckRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 18358  		}
 18359  		switch fieldNum {
 18360  		case 1:
 18361  			if wireType != 2 {
 18362  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 18363  			}
 18364  			var msglen int
 18365  			for shift := uint(0); ; shift += 7 {
 18366  				if shift >= 64 {
 18367  					return ErrIntOverflow
 18368  				}
 18369  				if iNdEx >= l {
 18370  					return io.ErrUnexpectedEOF
 18371  				}
 18372  				b := dAtA[iNdEx]
 18373  				iNdEx++
 18374  				msglen |= int(b&0x7F) << shift
 18375  				if b < 0x80 {
 18376  					break
 18377  				}
 18378  			}
 18379  			if msglen < 0 {
 18380  				return ErrInvalidLength
 18381  			}
 18382  			postIndex := iNdEx + msglen
 18383  			if postIndex < 0 {
 18384  				return ErrInvalidLength
 18385  			}
 18386  			if postIndex > l {
 18387  				return io.ErrUnexpectedEOF
 18388  			}
 18389  			if m.Alias == nil {
 18390  				m.Alias = &topodata.TabletAlias{}
 18391  			}
 18392  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18393  				return err
 18394  			}
 18395  			iNdEx = postIndex
 18396  		case 2:
 18397  			if wireType != 2 {
 18398  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 18399  			}
 18400  			var stringLen uint64
 18401  			for shift := uint(0); ; shift += 7 {
 18402  				if shift >= 64 {
 18403  					return ErrIntOverflow
 18404  				}
 18405  				if iNdEx >= l {
 18406  					return io.ErrUnexpectedEOF
 18407  				}
 18408  				b := dAtA[iNdEx]
 18409  				iNdEx++
 18410  				stringLen |= uint64(b&0x7F) << shift
 18411  				if b < 0x80 {
 18412  					break
 18413  				}
 18414  			}
 18415  			intStringLen := int(stringLen)
 18416  			if intStringLen < 0 {
 18417  				return ErrInvalidLength
 18418  			}
 18419  			postIndex := iNdEx + intStringLen
 18420  			if postIndex < 0 {
 18421  				return ErrInvalidLength
 18422  			}
 18423  			if postIndex > l {
 18424  				return io.ErrUnexpectedEOF
 18425  			}
 18426  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 18427  			iNdEx = postIndex
 18428  		default:
 18429  			iNdEx = preIndex
 18430  			skippy, err := skip(dAtA[iNdEx:])
 18431  			if err != nil {
 18432  				return err
 18433  			}
 18434  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18435  				return ErrInvalidLength
 18436  			}
 18437  			if (iNdEx + skippy) > l {
 18438  				return io.ErrUnexpectedEOF
 18439  			}
 18440  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18441  			iNdEx += skippy
 18442  		}
 18443  	}
 18444  
 18445  	if iNdEx > l {
 18446  		return io.ErrUnexpectedEOF
 18447  	}
 18448  	return nil
 18449  }
 18450  func (m *RunHealthCheckResponse) UnmarshalVT(dAtA []byte) error {
 18451  	l := len(dAtA)
 18452  	iNdEx := 0
 18453  	for iNdEx < l {
 18454  		preIndex := iNdEx
 18455  		var wire uint64
 18456  		for shift := uint(0); ; shift += 7 {
 18457  			if shift >= 64 {
 18458  				return ErrIntOverflow
 18459  			}
 18460  			if iNdEx >= l {
 18461  				return io.ErrUnexpectedEOF
 18462  			}
 18463  			b := dAtA[iNdEx]
 18464  			iNdEx++
 18465  			wire |= uint64(b&0x7F) << shift
 18466  			if b < 0x80 {
 18467  				break
 18468  			}
 18469  		}
 18470  		fieldNum := int32(wire >> 3)
 18471  		wireType := int(wire & 0x7)
 18472  		if wireType == 4 {
 18473  			return fmt.Errorf("proto: RunHealthCheckResponse: wiretype end group for non-group")
 18474  		}
 18475  		if fieldNum <= 0 {
 18476  			return fmt.Errorf("proto: RunHealthCheckResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 18477  		}
 18478  		switch fieldNum {
 18479  		case 1:
 18480  			if wireType != 2 {
 18481  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 18482  			}
 18483  			var stringLen uint64
 18484  			for shift := uint(0); ; shift += 7 {
 18485  				if shift >= 64 {
 18486  					return ErrIntOverflow
 18487  				}
 18488  				if iNdEx >= l {
 18489  					return io.ErrUnexpectedEOF
 18490  				}
 18491  				b := dAtA[iNdEx]
 18492  				iNdEx++
 18493  				stringLen |= uint64(b&0x7F) << shift
 18494  				if b < 0x80 {
 18495  					break
 18496  				}
 18497  			}
 18498  			intStringLen := int(stringLen)
 18499  			if intStringLen < 0 {
 18500  				return ErrInvalidLength
 18501  			}
 18502  			postIndex := iNdEx + intStringLen
 18503  			if postIndex < 0 {
 18504  				return ErrInvalidLength
 18505  			}
 18506  			if postIndex > l {
 18507  				return io.ErrUnexpectedEOF
 18508  			}
 18509  			m.Status = string(dAtA[iNdEx:postIndex])
 18510  			iNdEx = postIndex
 18511  		case 2:
 18512  			if wireType != 2 {
 18513  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 18514  			}
 18515  			var msglen int
 18516  			for shift := uint(0); ; shift += 7 {
 18517  				if shift >= 64 {
 18518  					return ErrIntOverflow
 18519  				}
 18520  				if iNdEx >= l {
 18521  					return io.ErrUnexpectedEOF
 18522  				}
 18523  				b := dAtA[iNdEx]
 18524  				iNdEx++
 18525  				msglen |= int(b&0x7F) << shift
 18526  				if b < 0x80 {
 18527  					break
 18528  				}
 18529  			}
 18530  			if msglen < 0 {
 18531  				return ErrInvalidLength
 18532  			}
 18533  			postIndex := iNdEx + msglen
 18534  			if postIndex < 0 {
 18535  				return ErrInvalidLength
 18536  			}
 18537  			if postIndex > l {
 18538  				return io.ErrUnexpectedEOF
 18539  			}
 18540  			if m.Cluster == nil {
 18541  				m.Cluster = &Cluster{}
 18542  			}
 18543  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18544  				return err
 18545  			}
 18546  			iNdEx = postIndex
 18547  		default:
 18548  			iNdEx = preIndex
 18549  			skippy, err := skip(dAtA[iNdEx:])
 18550  			if err != nil {
 18551  				return err
 18552  			}
 18553  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18554  				return ErrInvalidLength
 18555  			}
 18556  			if (iNdEx + skippy) > l {
 18557  				return io.ErrUnexpectedEOF
 18558  			}
 18559  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18560  			iNdEx += skippy
 18561  		}
 18562  	}
 18563  
 18564  	if iNdEx > l {
 18565  		return io.ErrUnexpectedEOF
 18566  	}
 18567  	return nil
 18568  }
 18569  func (m *SetReadOnlyRequest) UnmarshalVT(dAtA []byte) error {
 18570  	l := len(dAtA)
 18571  	iNdEx := 0
 18572  	for iNdEx < l {
 18573  		preIndex := iNdEx
 18574  		var wire uint64
 18575  		for shift := uint(0); ; shift += 7 {
 18576  			if shift >= 64 {
 18577  				return ErrIntOverflow
 18578  			}
 18579  			if iNdEx >= l {
 18580  				return io.ErrUnexpectedEOF
 18581  			}
 18582  			b := dAtA[iNdEx]
 18583  			iNdEx++
 18584  			wire |= uint64(b&0x7F) << shift
 18585  			if b < 0x80 {
 18586  				break
 18587  			}
 18588  		}
 18589  		fieldNum := int32(wire >> 3)
 18590  		wireType := int(wire & 0x7)
 18591  		if wireType == 4 {
 18592  			return fmt.Errorf("proto: SetReadOnlyRequest: wiretype end group for non-group")
 18593  		}
 18594  		if fieldNum <= 0 {
 18595  			return fmt.Errorf("proto: SetReadOnlyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 18596  		}
 18597  		switch fieldNum {
 18598  		case 1:
 18599  			if wireType != 2 {
 18600  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 18601  			}
 18602  			var msglen int
 18603  			for shift := uint(0); ; shift += 7 {
 18604  				if shift >= 64 {
 18605  					return ErrIntOverflow
 18606  				}
 18607  				if iNdEx >= l {
 18608  					return io.ErrUnexpectedEOF
 18609  				}
 18610  				b := dAtA[iNdEx]
 18611  				iNdEx++
 18612  				msglen |= int(b&0x7F) << shift
 18613  				if b < 0x80 {
 18614  					break
 18615  				}
 18616  			}
 18617  			if msglen < 0 {
 18618  				return ErrInvalidLength
 18619  			}
 18620  			postIndex := iNdEx + msglen
 18621  			if postIndex < 0 {
 18622  				return ErrInvalidLength
 18623  			}
 18624  			if postIndex > l {
 18625  				return io.ErrUnexpectedEOF
 18626  			}
 18627  			if m.Alias == nil {
 18628  				m.Alias = &topodata.TabletAlias{}
 18629  			}
 18630  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18631  				return err
 18632  			}
 18633  			iNdEx = postIndex
 18634  		case 2:
 18635  			if wireType != 2 {
 18636  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 18637  			}
 18638  			var stringLen uint64
 18639  			for shift := uint(0); ; shift += 7 {
 18640  				if shift >= 64 {
 18641  					return ErrIntOverflow
 18642  				}
 18643  				if iNdEx >= l {
 18644  					return io.ErrUnexpectedEOF
 18645  				}
 18646  				b := dAtA[iNdEx]
 18647  				iNdEx++
 18648  				stringLen |= uint64(b&0x7F) << shift
 18649  				if b < 0x80 {
 18650  					break
 18651  				}
 18652  			}
 18653  			intStringLen := int(stringLen)
 18654  			if intStringLen < 0 {
 18655  				return ErrInvalidLength
 18656  			}
 18657  			postIndex := iNdEx + intStringLen
 18658  			if postIndex < 0 {
 18659  				return ErrInvalidLength
 18660  			}
 18661  			if postIndex > l {
 18662  				return io.ErrUnexpectedEOF
 18663  			}
 18664  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 18665  			iNdEx = postIndex
 18666  		default:
 18667  			iNdEx = preIndex
 18668  			skippy, err := skip(dAtA[iNdEx:])
 18669  			if err != nil {
 18670  				return err
 18671  			}
 18672  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18673  				return ErrInvalidLength
 18674  			}
 18675  			if (iNdEx + skippy) > l {
 18676  				return io.ErrUnexpectedEOF
 18677  			}
 18678  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18679  			iNdEx += skippy
 18680  		}
 18681  	}
 18682  
 18683  	if iNdEx > l {
 18684  		return io.ErrUnexpectedEOF
 18685  	}
 18686  	return nil
 18687  }
 18688  func (m *SetReadOnlyResponse) UnmarshalVT(dAtA []byte) error {
 18689  	l := len(dAtA)
 18690  	iNdEx := 0
 18691  	for iNdEx < l {
 18692  		preIndex := iNdEx
 18693  		var wire uint64
 18694  		for shift := uint(0); ; shift += 7 {
 18695  			if shift >= 64 {
 18696  				return ErrIntOverflow
 18697  			}
 18698  			if iNdEx >= l {
 18699  				return io.ErrUnexpectedEOF
 18700  			}
 18701  			b := dAtA[iNdEx]
 18702  			iNdEx++
 18703  			wire |= uint64(b&0x7F) << shift
 18704  			if b < 0x80 {
 18705  				break
 18706  			}
 18707  		}
 18708  		fieldNum := int32(wire >> 3)
 18709  		wireType := int(wire & 0x7)
 18710  		if wireType == 4 {
 18711  			return fmt.Errorf("proto: SetReadOnlyResponse: wiretype end group for non-group")
 18712  		}
 18713  		if fieldNum <= 0 {
 18714  			return fmt.Errorf("proto: SetReadOnlyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 18715  		}
 18716  		switch fieldNum {
 18717  		default:
 18718  			iNdEx = preIndex
 18719  			skippy, err := skip(dAtA[iNdEx:])
 18720  			if err != nil {
 18721  				return err
 18722  			}
 18723  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18724  				return ErrInvalidLength
 18725  			}
 18726  			if (iNdEx + skippy) > l {
 18727  				return io.ErrUnexpectedEOF
 18728  			}
 18729  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18730  			iNdEx += skippy
 18731  		}
 18732  	}
 18733  
 18734  	if iNdEx > l {
 18735  		return io.ErrUnexpectedEOF
 18736  	}
 18737  	return nil
 18738  }
 18739  func (m *SetReadWriteRequest) UnmarshalVT(dAtA []byte) error {
 18740  	l := len(dAtA)
 18741  	iNdEx := 0
 18742  	for iNdEx < l {
 18743  		preIndex := iNdEx
 18744  		var wire uint64
 18745  		for shift := uint(0); ; shift += 7 {
 18746  			if shift >= 64 {
 18747  				return ErrIntOverflow
 18748  			}
 18749  			if iNdEx >= l {
 18750  				return io.ErrUnexpectedEOF
 18751  			}
 18752  			b := dAtA[iNdEx]
 18753  			iNdEx++
 18754  			wire |= uint64(b&0x7F) << shift
 18755  			if b < 0x80 {
 18756  				break
 18757  			}
 18758  		}
 18759  		fieldNum := int32(wire >> 3)
 18760  		wireType := int(wire & 0x7)
 18761  		if wireType == 4 {
 18762  			return fmt.Errorf("proto: SetReadWriteRequest: wiretype end group for non-group")
 18763  		}
 18764  		if fieldNum <= 0 {
 18765  			return fmt.Errorf("proto: SetReadWriteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 18766  		}
 18767  		switch fieldNum {
 18768  		case 1:
 18769  			if wireType != 2 {
 18770  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 18771  			}
 18772  			var msglen int
 18773  			for shift := uint(0); ; shift += 7 {
 18774  				if shift >= 64 {
 18775  					return ErrIntOverflow
 18776  				}
 18777  				if iNdEx >= l {
 18778  					return io.ErrUnexpectedEOF
 18779  				}
 18780  				b := dAtA[iNdEx]
 18781  				iNdEx++
 18782  				msglen |= int(b&0x7F) << shift
 18783  				if b < 0x80 {
 18784  					break
 18785  				}
 18786  			}
 18787  			if msglen < 0 {
 18788  				return ErrInvalidLength
 18789  			}
 18790  			postIndex := iNdEx + msglen
 18791  			if postIndex < 0 {
 18792  				return ErrInvalidLength
 18793  			}
 18794  			if postIndex > l {
 18795  				return io.ErrUnexpectedEOF
 18796  			}
 18797  			if m.Alias == nil {
 18798  				m.Alias = &topodata.TabletAlias{}
 18799  			}
 18800  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18801  				return err
 18802  			}
 18803  			iNdEx = postIndex
 18804  		case 2:
 18805  			if wireType != 2 {
 18806  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 18807  			}
 18808  			var stringLen uint64
 18809  			for shift := uint(0); ; shift += 7 {
 18810  				if shift >= 64 {
 18811  					return ErrIntOverflow
 18812  				}
 18813  				if iNdEx >= l {
 18814  					return io.ErrUnexpectedEOF
 18815  				}
 18816  				b := dAtA[iNdEx]
 18817  				iNdEx++
 18818  				stringLen |= uint64(b&0x7F) << shift
 18819  				if b < 0x80 {
 18820  					break
 18821  				}
 18822  			}
 18823  			intStringLen := int(stringLen)
 18824  			if intStringLen < 0 {
 18825  				return ErrInvalidLength
 18826  			}
 18827  			postIndex := iNdEx + intStringLen
 18828  			if postIndex < 0 {
 18829  				return ErrInvalidLength
 18830  			}
 18831  			if postIndex > l {
 18832  				return io.ErrUnexpectedEOF
 18833  			}
 18834  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 18835  			iNdEx = postIndex
 18836  		default:
 18837  			iNdEx = preIndex
 18838  			skippy, err := skip(dAtA[iNdEx:])
 18839  			if err != nil {
 18840  				return err
 18841  			}
 18842  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18843  				return ErrInvalidLength
 18844  			}
 18845  			if (iNdEx + skippy) > l {
 18846  				return io.ErrUnexpectedEOF
 18847  			}
 18848  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18849  			iNdEx += skippy
 18850  		}
 18851  	}
 18852  
 18853  	if iNdEx > l {
 18854  		return io.ErrUnexpectedEOF
 18855  	}
 18856  	return nil
 18857  }
 18858  func (m *SetReadWriteResponse) UnmarshalVT(dAtA []byte) error {
 18859  	l := len(dAtA)
 18860  	iNdEx := 0
 18861  	for iNdEx < l {
 18862  		preIndex := iNdEx
 18863  		var wire uint64
 18864  		for shift := uint(0); ; shift += 7 {
 18865  			if shift >= 64 {
 18866  				return ErrIntOverflow
 18867  			}
 18868  			if iNdEx >= l {
 18869  				return io.ErrUnexpectedEOF
 18870  			}
 18871  			b := dAtA[iNdEx]
 18872  			iNdEx++
 18873  			wire |= uint64(b&0x7F) << shift
 18874  			if b < 0x80 {
 18875  				break
 18876  			}
 18877  		}
 18878  		fieldNum := int32(wire >> 3)
 18879  		wireType := int(wire & 0x7)
 18880  		if wireType == 4 {
 18881  			return fmt.Errorf("proto: SetReadWriteResponse: wiretype end group for non-group")
 18882  		}
 18883  		if fieldNum <= 0 {
 18884  			return fmt.Errorf("proto: SetReadWriteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 18885  		}
 18886  		switch fieldNum {
 18887  		default:
 18888  			iNdEx = preIndex
 18889  			skippy, err := skip(dAtA[iNdEx:])
 18890  			if err != nil {
 18891  				return err
 18892  			}
 18893  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 18894  				return ErrInvalidLength
 18895  			}
 18896  			if (iNdEx + skippy) > l {
 18897  				return io.ErrUnexpectedEOF
 18898  			}
 18899  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 18900  			iNdEx += skippy
 18901  		}
 18902  	}
 18903  
 18904  	if iNdEx > l {
 18905  		return io.ErrUnexpectedEOF
 18906  	}
 18907  	return nil
 18908  }
 18909  func (m *StartReplicationRequest) UnmarshalVT(dAtA []byte) error {
 18910  	l := len(dAtA)
 18911  	iNdEx := 0
 18912  	for iNdEx < l {
 18913  		preIndex := iNdEx
 18914  		var wire uint64
 18915  		for shift := uint(0); ; shift += 7 {
 18916  			if shift >= 64 {
 18917  				return ErrIntOverflow
 18918  			}
 18919  			if iNdEx >= l {
 18920  				return io.ErrUnexpectedEOF
 18921  			}
 18922  			b := dAtA[iNdEx]
 18923  			iNdEx++
 18924  			wire |= uint64(b&0x7F) << shift
 18925  			if b < 0x80 {
 18926  				break
 18927  			}
 18928  		}
 18929  		fieldNum := int32(wire >> 3)
 18930  		wireType := int(wire & 0x7)
 18931  		if wireType == 4 {
 18932  			return fmt.Errorf("proto: StartReplicationRequest: wiretype end group for non-group")
 18933  		}
 18934  		if fieldNum <= 0 {
 18935  			return fmt.Errorf("proto: StartReplicationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 18936  		}
 18937  		switch fieldNum {
 18938  		case 1:
 18939  			if wireType != 2 {
 18940  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 18941  			}
 18942  			var msglen int
 18943  			for shift := uint(0); ; shift += 7 {
 18944  				if shift >= 64 {
 18945  					return ErrIntOverflow
 18946  				}
 18947  				if iNdEx >= l {
 18948  					return io.ErrUnexpectedEOF
 18949  				}
 18950  				b := dAtA[iNdEx]
 18951  				iNdEx++
 18952  				msglen |= int(b&0x7F) << shift
 18953  				if b < 0x80 {
 18954  					break
 18955  				}
 18956  			}
 18957  			if msglen < 0 {
 18958  				return ErrInvalidLength
 18959  			}
 18960  			postIndex := iNdEx + msglen
 18961  			if postIndex < 0 {
 18962  				return ErrInvalidLength
 18963  			}
 18964  			if postIndex > l {
 18965  				return io.ErrUnexpectedEOF
 18966  			}
 18967  			if m.Alias == nil {
 18968  				m.Alias = &topodata.TabletAlias{}
 18969  			}
 18970  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 18971  				return err
 18972  			}
 18973  			iNdEx = postIndex
 18974  		case 2:
 18975  			if wireType != 2 {
 18976  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 18977  			}
 18978  			var stringLen uint64
 18979  			for shift := uint(0); ; shift += 7 {
 18980  				if shift >= 64 {
 18981  					return ErrIntOverflow
 18982  				}
 18983  				if iNdEx >= l {
 18984  					return io.ErrUnexpectedEOF
 18985  				}
 18986  				b := dAtA[iNdEx]
 18987  				iNdEx++
 18988  				stringLen |= uint64(b&0x7F) << shift
 18989  				if b < 0x80 {
 18990  					break
 18991  				}
 18992  			}
 18993  			intStringLen := int(stringLen)
 18994  			if intStringLen < 0 {
 18995  				return ErrInvalidLength
 18996  			}
 18997  			postIndex := iNdEx + intStringLen
 18998  			if postIndex < 0 {
 18999  				return ErrInvalidLength
 19000  			}
 19001  			if postIndex > l {
 19002  				return io.ErrUnexpectedEOF
 19003  			}
 19004  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 19005  			iNdEx = postIndex
 19006  		default:
 19007  			iNdEx = preIndex
 19008  			skippy, err := skip(dAtA[iNdEx:])
 19009  			if err != nil {
 19010  				return err
 19011  			}
 19012  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19013  				return ErrInvalidLength
 19014  			}
 19015  			if (iNdEx + skippy) > l {
 19016  				return io.ErrUnexpectedEOF
 19017  			}
 19018  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19019  			iNdEx += skippy
 19020  		}
 19021  	}
 19022  
 19023  	if iNdEx > l {
 19024  		return io.ErrUnexpectedEOF
 19025  	}
 19026  	return nil
 19027  }
 19028  func (m *StartReplicationResponse) UnmarshalVT(dAtA []byte) error {
 19029  	l := len(dAtA)
 19030  	iNdEx := 0
 19031  	for iNdEx < l {
 19032  		preIndex := iNdEx
 19033  		var wire uint64
 19034  		for shift := uint(0); ; shift += 7 {
 19035  			if shift >= 64 {
 19036  				return ErrIntOverflow
 19037  			}
 19038  			if iNdEx >= l {
 19039  				return io.ErrUnexpectedEOF
 19040  			}
 19041  			b := dAtA[iNdEx]
 19042  			iNdEx++
 19043  			wire |= uint64(b&0x7F) << shift
 19044  			if b < 0x80 {
 19045  				break
 19046  			}
 19047  		}
 19048  		fieldNum := int32(wire >> 3)
 19049  		wireType := int(wire & 0x7)
 19050  		if wireType == 4 {
 19051  			return fmt.Errorf("proto: StartReplicationResponse: wiretype end group for non-group")
 19052  		}
 19053  		if fieldNum <= 0 {
 19054  			return fmt.Errorf("proto: StartReplicationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 19055  		}
 19056  		switch fieldNum {
 19057  		case 1:
 19058  			if wireType != 2 {
 19059  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 19060  			}
 19061  			var stringLen uint64
 19062  			for shift := uint(0); ; shift += 7 {
 19063  				if shift >= 64 {
 19064  					return ErrIntOverflow
 19065  				}
 19066  				if iNdEx >= l {
 19067  					return io.ErrUnexpectedEOF
 19068  				}
 19069  				b := dAtA[iNdEx]
 19070  				iNdEx++
 19071  				stringLen |= uint64(b&0x7F) << shift
 19072  				if b < 0x80 {
 19073  					break
 19074  				}
 19075  			}
 19076  			intStringLen := int(stringLen)
 19077  			if intStringLen < 0 {
 19078  				return ErrInvalidLength
 19079  			}
 19080  			postIndex := iNdEx + intStringLen
 19081  			if postIndex < 0 {
 19082  				return ErrInvalidLength
 19083  			}
 19084  			if postIndex > l {
 19085  				return io.ErrUnexpectedEOF
 19086  			}
 19087  			m.Status = string(dAtA[iNdEx:postIndex])
 19088  			iNdEx = postIndex
 19089  		case 2:
 19090  			if wireType != 2 {
 19091  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 19092  			}
 19093  			var msglen int
 19094  			for shift := uint(0); ; shift += 7 {
 19095  				if shift >= 64 {
 19096  					return ErrIntOverflow
 19097  				}
 19098  				if iNdEx >= l {
 19099  					return io.ErrUnexpectedEOF
 19100  				}
 19101  				b := dAtA[iNdEx]
 19102  				iNdEx++
 19103  				msglen |= int(b&0x7F) << shift
 19104  				if b < 0x80 {
 19105  					break
 19106  				}
 19107  			}
 19108  			if msglen < 0 {
 19109  				return ErrInvalidLength
 19110  			}
 19111  			postIndex := iNdEx + msglen
 19112  			if postIndex < 0 {
 19113  				return ErrInvalidLength
 19114  			}
 19115  			if postIndex > l {
 19116  				return io.ErrUnexpectedEOF
 19117  			}
 19118  			if m.Cluster == nil {
 19119  				m.Cluster = &Cluster{}
 19120  			}
 19121  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19122  				return err
 19123  			}
 19124  			iNdEx = postIndex
 19125  		default:
 19126  			iNdEx = preIndex
 19127  			skippy, err := skip(dAtA[iNdEx:])
 19128  			if err != nil {
 19129  				return err
 19130  			}
 19131  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19132  				return ErrInvalidLength
 19133  			}
 19134  			if (iNdEx + skippy) > l {
 19135  				return io.ErrUnexpectedEOF
 19136  			}
 19137  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19138  			iNdEx += skippy
 19139  		}
 19140  	}
 19141  
 19142  	if iNdEx > l {
 19143  		return io.ErrUnexpectedEOF
 19144  	}
 19145  	return nil
 19146  }
 19147  func (m *StopReplicationRequest) UnmarshalVT(dAtA []byte) error {
 19148  	l := len(dAtA)
 19149  	iNdEx := 0
 19150  	for iNdEx < l {
 19151  		preIndex := iNdEx
 19152  		var wire uint64
 19153  		for shift := uint(0); ; shift += 7 {
 19154  			if shift >= 64 {
 19155  				return ErrIntOverflow
 19156  			}
 19157  			if iNdEx >= l {
 19158  				return io.ErrUnexpectedEOF
 19159  			}
 19160  			b := dAtA[iNdEx]
 19161  			iNdEx++
 19162  			wire |= uint64(b&0x7F) << shift
 19163  			if b < 0x80 {
 19164  				break
 19165  			}
 19166  		}
 19167  		fieldNum := int32(wire >> 3)
 19168  		wireType := int(wire & 0x7)
 19169  		if wireType == 4 {
 19170  			return fmt.Errorf("proto: StopReplicationRequest: wiretype end group for non-group")
 19171  		}
 19172  		if fieldNum <= 0 {
 19173  			return fmt.Errorf("proto: StopReplicationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 19174  		}
 19175  		switch fieldNum {
 19176  		case 1:
 19177  			if wireType != 2 {
 19178  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 19179  			}
 19180  			var msglen int
 19181  			for shift := uint(0); ; shift += 7 {
 19182  				if shift >= 64 {
 19183  					return ErrIntOverflow
 19184  				}
 19185  				if iNdEx >= l {
 19186  					return io.ErrUnexpectedEOF
 19187  				}
 19188  				b := dAtA[iNdEx]
 19189  				iNdEx++
 19190  				msglen |= int(b&0x7F) << shift
 19191  				if b < 0x80 {
 19192  					break
 19193  				}
 19194  			}
 19195  			if msglen < 0 {
 19196  				return ErrInvalidLength
 19197  			}
 19198  			postIndex := iNdEx + msglen
 19199  			if postIndex < 0 {
 19200  				return ErrInvalidLength
 19201  			}
 19202  			if postIndex > l {
 19203  				return io.ErrUnexpectedEOF
 19204  			}
 19205  			if m.Alias == nil {
 19206  				m.Alias = &topodata.TabletAlias{}
 19207  			}
 19208  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19209  				return err
 19210  			}
 19211  			iNdEx = postIndex
 19212  		case 2:
 19213  			if wireType != 2 {
 19214  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 19215  			}
 19216  			var stringLen uint64
 19217  			for shift := uint(0); ; shift += 7 {
 19218  				if shift >= 64 {
 19219  					return ErrIntOverflow
 19220  				}
 19221  				if iNdEx >= l {
 19222  					return io.ErrUnexpectedEOF
 19223  				}
 19224  				b := dAtA[iNdEx]
 19225  				iNdEx++
 19226  				stringLen |= uint64(b&0x7F) << shift
 19227  				if b < 0x80 {
 19228  					break
 19229  				}
 19230  			}
 19231  			intStringLen := int(stringLen)
 19232  			if intStringLen < 0 {
 19233  				return ErrInvalidLength
 19234  			}
 19235  			postIndex := iNdEx + intStringLen
 19236  			if postIndex < 0 {
 19237  				return ErrInvalidLength
 19238  			}
 19239  			if postIndex > l {
 19240  				return io.ErrUnexpectedEOF
 19241  			}
 19242  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 19243  			iNdEx = postIndex
 19244  		default:
 19245  			iNdEx = preIndex
 19246  			skippy, err := skip(dAtA[iNdEx:])
 19247  			if err != nil {
 19248  				return err
 19249  			}
 19250  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19251  				return ErrInvalidLength
 19252  			}
 19253  			if (iNdEx + skippy) > l {
 19254  				return io.ErrUnexpectedEOF
 19255  			}
 19256  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19257  			iNdEx += skippy
 19258  		}
 19259  	}
 19260  
 19261  	if iNdEx > l {
 19262  		return io.ErrUnexpectedEOF
 19263  	}
 19264  	return nil
 19265  }
 19266  func (m *StopReplicationResponse) UnmarshalVT(dAtA []byte) error {
 19267  	l := len(dAtA)
 19268  	iNdEx := 0
 19269  	for iNdEx < l {
 19270  		preIndex := iNdEx
 19271  		var wire uint64
 19272  		for shift := uint(0); ; shift += 7 {
 19273  			if shift >= 64 {
 19274  				return ErrIntOverflow
 19275  			}
 19276  			if iNdEx >= l {
 19277  				return io.ErrUnexpectedEOF
 19278  			}
 19279  			b := dAtA[iNdEx]
 19280  			iNdEx++
 19281  			wire |= uint64(b&0x7F) << shift
 19282  			if b < 0x80 {
 19283  				break
 19284  			}
 19285  		}
 19286  		fieldNum := int32(wire >> 3)
 19287  		wireType := int(wire & 0x7)
 19288  		if wireType == 4 {
 19289  			return fmt.Errorf("proto: StopReplicationResponse: wiretype end group for non-group")
 19290  		}
 19291  		if fieldNum <= 0 {
 19292  			return fmt.Errorf("proto: StopReplicationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 19293  		}
 19294  		switch fieldNum {
 19295  		case 1:
 19296  			if wireType != 2 {
 19297  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 19298  			}
 19299  			var stringLen uint64
 19300  			for shift := uint(0); ; shift += 7 {
 19301  				if shift >= 64 {
 19302  					return ErrIntOverflow
 19303  				}
 19304  				if iNdEx >= l {
 19305  					return io.ErrUnexpectedEOF
 19306  				}
 19307  				b := dAtA[iNdEx]
 19308  				iNdEx++
 19309  				stringLen |= uint64(b&0x7F) << shift
 19310  				if b < 0x80 {
 19311  					break
 19312  				}
 19313  			}
 19314  			intStringLen := int(stringLen)
 19315  			if intStringLen < 0 {
 19316  				return ErrInvalidLength
 19317  			}
 19318  			postIndex := iNdEx + intStringLen
 19319  			if postIndex < 0 {
 19320  				return ErrInvalidLength
 19321  			}
 19322  			if postIndex > l {
 19323  				return io.ErrUnexpectedEOF
 19324  			}
 19325  			m.Status = string(dAtA[iNdEx:postIndex])
 19326  			iNdEx = postIndex
 19327  		case 2:
 19328  			if wireType != 2 {
 19329  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 19330  			}
 19331  			var msglen int
 19332  			for shift := uint(0); ; shift += 7 {
 19333  				if shift >= 64 {
 19334  					return ErrIntOverflow
 19335  				}
 19336  				if iNdEx >= l {
 19337  					return io.ErrUnexpectedEOF
 19338  				}
 19339  				b := dAtA[iNdEx]
 19340  				iNdEx++
 19341  				msglen |= int(b&0x7F) << shift
 19342  				if b < 0x80 {
 19343  					break
 19344  				}
 19345  			}
 19346  			if msglen < 0 {
 19347  				return ErrInvalidLength
 19348  			}
 19349  			postIndex := iNdEx + msglen
 19350  			if postIndex < 0 {
 19351  				return ErrInvalidLength
 19352  			}
 19353  			if postIndex > l {
 19354  				return io.ErrUnexpectedEOF
 19355  			}
 19356  			if m.Cluster == nil {
 19357  				m.Cluster = &Cluster{}
 19358  			}
 19359  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19360  				return err
 19361  			}
 19362  			iNdEx = postIndex
 19363  		default:
 19364  			iNdEx = preIndex
 19365  			skippy, err := skip(dAtA[iNdEx:])
 19366  			if err != nil {
 19367  				return err
 19368  			}
 19369  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19370  				return ErrInvalidLength
 19371  			}
 19372  			if (iNdEx + skippy) > l {
 19373  				return io.ErrUnexpectedEOF
 19374  			}
 19375  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19376  			iNdEx += skippy
 19377  		}
 19378  	}
 19379  
 19380  	if iNdEx > l {
 19381  		return io.ErrUnexpectedEOF
 19382  	}
 19383  	return nil
 19384  }
 19385  func (m *TabletExternallyPromotedRequest) UnmarshalVT(dAtA []byte) error {
 19386  	l := len(dAtA)
 19387  	iNdEx := 0
 19388  	for iNdEx < l {
 19389  		preIndex := iNdEx
 19390  		var wire uint64
 19391  		for shift := uint(0); ; shift += 7 {
 19392  			if shift >= 64 {
 19393  				return ErrIntOverflow
 19394  			}
 19395  			if iNdEx >= l {
 19396  				return io.ErrUnexpectedEOF
 19397  			}
 19398  			b := dAtA[iNdEx]
 19399  			iNdEx++
 19400  			wire |= uint64(b&0x7F) << shift
 19401  			if b < 0x80 {
 19402  				break
 19403  			}
 19404  		}
 19405  		fieldNum := int32(wire >> 3)
 19406  		wireType := int(wire & 0x7)
 19407  		if wireType == 4 {
 19408  			return fmt.Errorf("proto: TabletExternallyPromotedRequest: wiretype end group for non-group")
 19409  		}
 19410  		if fieldNum <= 0 {
 19411  			return fmt.Errorf("proto: TabletExternallyPromotedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 19412  		}
 19413  		switch fieldNum {
 19414  		case 1:
 19415  			if wireType != 2 {
 19416  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 19417  			}
 19418  			var msglen int
 19419  			for shift := uint(0); ; shift += 7 {
 19420  				if shift >= 64 {
 19421  					return ErrIntOverflow
 19422  				}
 19423  				if iNdEx >= l {
 19424  					return io.ErrUnexpectedEOF
 19425  				}
 19426  				b := dAtA[iNdEx]
 19427  				iNdEx++
 19428  				msglen |= int(b&0x7F) << shift
 19429  				if b < 0x80 {
 19430  					break
 19431  				}
 19432  			}
 19433  			if msglen < 0 {
 19434  				return ErrInvalidLength
 19435  			}
 19436  			postIndex := iNdEx + msglen
 19437  			if postIndex < 0 {
 19438  				return ErrInvalidLength
 19439  			}
 19440  			if postIndex > l {
 19441  				return io.ErrUnexpectedEOF
 19442  			}
 19443  			if m.Alias == nil {
 19444  				m.Alias = &topodata.TabletAlias{}
 19445  			}
 19446  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19447  				return err
 19448  			}
 19449  			iNdEx = postIndex
 19450  		case 2:
 19451  			if wireType != 2 {
 19452  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 19453  			}
 19454  			var stringLen uint64
 19455  			for shift := uint(0); ; shift += 7 {
 19456  				if shift >= 64 {
 19457  					return ErrIntOverflow
 19458  				}
 19459  				if iNdEx >= l {
 19460  					return io.ErrUnexpectedEOF
 19461  				}
 19462  				b := dAtA[iNdEx]
 19463  				iNdEx++
 19464  				stringLen |= uint64(b&0x7F) << shift
 19465  				if b < 0x80 {
 19466  					break
 19467  				}
 19468  			}
 19469  			intStringLen := int(stringLen)
 19470  			if intStringLen < 0 {
 19471  				return ErrInvalidLength
 19472  			}
 19473  			postIndex := iNdEx + intStringLen
 19474  			if postIndex < 0 {
 19475  				return ErrInvalidLength
 19476  			}
 19477  			if postIndex > l {
 19478  				return io.ErrUnexpectedEOF
 19479  			}
 19480  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 19481  			iNdEx = postIndex
 19482  		default:
 19483  			iNdEx = preIndex
 19484  			skippy, err := skip(dAtA[iNdEx:])
 19485  			if err != nil {
 19486  				return err
 19487  			}
 19488  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19489  				return ErrInvalidLength
 19490  			}
 19491  			if (iNdEx + skippy) > l {
 19492  				return io.ErrUnexpectedEOF
 19493  			}
 19494  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19495  			iNdEx += skippy
 19496  		}
 19497  	}
 19498  
 19499  	if iNdEx > l {
 19500  		return io.ErrUnexpectedEOF
 19501  	}
 19502  	return nil
 19503  }
 19504  func (m *TabletExternallyPromotedResponse) UnmarshalVT(dAtA []byte) error {
 19505  	l := len(dAtA)
 19506  	iNdEx := 0
 19507  	for iNdEx < l {
 19508  		preIndex := iNdEx
 19509  		var wire uint64
 19510  		for shift := uint(0); ; shift += 7 {
 19511  			if shift >= 64 {
 19512  				return ErrIntOverflow
 19513  			}
 19514  			if iNdEx >= l {
 19515  				return io.ErrUnexpectedEOF
 19516  			}
 19517  			b := dAtA[iNdEx]
 19518  			iNdEx++
 19519  			wire |= uint64(b&0x7F) << shift
 19520  			if b < 0x80 {
 19521  				break
 19522  			}
 19523  		}
 19524  		fieldNum := int32(wire >> 3)
 19525  		wireType := int(wire & 0x7)
 19526  		if wireType == 4 {
 19527  			return fmt.Errorf("proto: TabletExternallyPromotedResponse: wiretype end group for non-group")
 19528  		}
 19529  		if fieldNum <= 0 {
 19530  			return fmt.Errorf("proto: TabletExternallyPromotedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 19531  		}
 19532  		switch fieldNum {
 19533  		case 1:
 19534  			if wireType != 2 {
 19535  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 19536  			}
 19537  			var msglen int
 19538  			for shift := uint(0); ; shift += 7 {
 19539  				if shift >= 64 {
 19540  					return ErrIntOverflow
 19541  				}
 19542  				if iNdEx >= l {
 19543  					return io.ErrUnexpectedEOF
 19544  				}
 19545  				b := dAtA[iNdEx]
 19546  				iNdEx++
 19547  				msglen |= int(b&0x7F) << shift
 19548  				if b < 0x80 {
 19549  					break
 19550  				}
 19551  			}
 19552  			if msglen < 0 {
 19553  				return ErrInvalidLength
 19554  			}
 19555  			postIndex := iNdEx + msglen
 19556  			if postIndex < 0 {
 19557  				return ErrInvalidLength
 19558  			}
 19559  			if postIndex > l {
 19560  				return io.ErrUnexpectedEOF
 19561  			}
 19562  			if m.Cluster == nil {
 19563  				m.Cluster = &Cluster{}
 19564  			}
 19565  			if err := m.Cluster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19566  				return err
 19567  			}
 19568  			iNdEx = postIndex
 19569  		case 2:
 19570  			if wireType != 2 {
 19571  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 19572  			}
 19573  			var stringLen uint64
 19574  			for shift := uint(0); ; shift += 7 {
 19575  				if shift >= 64 {
 19576  					return ErrIntOverflow
 19577  				}
 19578  				if iNdEx >= l {
 19579  					return io.ErrUnexpectedEOF
 19580  				}
 19581  				b := dAtA[iNdEx]
 19582  				iNdEx++
 19583  				stringLen |= uint64(b&0x7F) << shift
 19584  				if b < 0x80 {
 19585  					break
 19586  				}
 19587  			}
 19588  			intStringLen := int(stringLen)
 19589  			if intStringLen < 0 {
 19590  				return ErrInvalidLength
 19591  			}
 19592  			postIndex := iNdEx + intStringLen
 19593  			if postIndex < 0 {
 19594  				return ErrInvalidLength
 19595  			}
 19596  			if postIndex > l {
 19597  				return io.ErrUnexpectedEOF
 19598  			}
 19599  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 19600  			iNdEx = postIndex
 19601  		case 3:
 19602  			if wireType != 2 {
 19603  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 19604  			}
 19605  			var stringLen uint64
 19606  			for shift := uint(0); ; shift += 7 {
 19607  				if shift >= 64 {
 19608  					return ErrIntOverflow
 19609  				}
 19610  				if iNdEx >= l {
 19611  					return io.ErrUnexpectedEOF
 19612  				}
 19613  				b := dAtA[iNdEx]
 19614  				iNdEx++
 19615  				stringLen |= uint64(b&0x7F) << shift
 19616  				if b < 0x80 {
 19617  					break
 19618  				}
 19619  			}
 19620  			intStringLen := int(stringLen)
 19621  			if intStringLen < 0 {
 19622  				return ErrInvalidLength
 19623  			}
 19624  			postIndex := iNdEx + intStringLen
 19625  			if postIndex < 0 {
 19626  				return ErrInvalidLength
 19627  			}
 19628  			if postIndex > l {
 19629  				return io.ErrUnexpectedEOF
 19630  			}
 19631  			m.Shard = string(dAtA[iNdEx:postIndex])
 19632  			iNdEx = postIndex
 19633  		case 4:
 19634  			if wireType != 2 {
 19635  				return fmt.Errorf("proto: wrong wireType = %d for field NewPrimary", wireType)
 19636  			}
 19637  			var msglen int
 19638  			for shift := uint(0); ; shift += 7 {
 19639  				if shift >= 64 {
 19640  					return ErrIntOverflow
 19641  				}
 19642  				if iNdEx >= l {
 19643  					return io.ErrUnexpectedEOF
 19644  				}
 19645  				b := dAtA[iNdEx]
 19646  				iNdEx++
 19647  				msglen |= int(b&0x7F) << shift
 19648  				if b < 0x80 {
 19649  					break
 19650  				}
 19651  			}
 19652  			if msglen < 0 {
 19653  				return ErrInvalidLength
 19654  			}
 19655  			postIndex := iNdEx + msglen
 19656  			if postIndex < 0 {
 19657  				return ErrInvalidLength
 19658  			}
 19659  			if postIndex > l {
 19660  				return io.ErrUnexpectedEOF
 19661  			}
 19662  			if m.NewPrimary == nil {
 19663  				m.NewPrimary = &topodata.TabletAlias{}
 19664  			}
 19665  			if err := m.NewPrimary.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19666  				return err
 19667  			}
 19668  			iNdEx = postIndex
 19669  		case 5:
 19670  			if wireType != 2 {
 19671  				return fmt.Errorf("proto: wrong wireType = %d for field OldPrimary", wireType)
 19672  			}
 19673  			var msglen int
 19674  			for shift := uint(0); ; shift += 7 {
 19675  				if shift >= 64 {
 19676  					return ErrIntOverflow
 19677  				}
 19678  				if iNdEx >= l {
 19679  					return io.ErrUnexpectedEOF
 19680  				}
 19681  				b := dAtA[iNdEx]
 19682  				iNdEx++
 19683  				msglen |= int(b&0x7F) << shift
 19684  				if b < 0x80 {
 19685  					break
 19686  				}
 19687  			}
 19688  			if msglen < 0 {
 19689  				return ErrInvalidLength
 19690  			}
 19691  			postIndex := iNdEx + msglen
 19692  			if postIndex < 0 {
 19693  				return ErrInvalidLength
 19694  			}
 19695  			if postIndex > l {
 19696  				return io.ErrUnexpectedEOF
 19697  			}
 19698  			if m.OldPrimary == nil {
 19699  				m.OldPrimary = &topodata.TabletAlias{}
 19700  			}
 19701  			if err := m.OldPrimary.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19702  				return err
 19703  			}
 19704  			iNdEx = postIndex
 19705  		default:
 19706  			iNdEx = preIndex
 19707  			skippy, err := skip(dAtA[iNdEx:])
 19708  			if err != nil {
 19709  				return err
 19710  			}
 19711  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19712  				return ErrInvalidLength
 19713  			}
 19714  			if (iNdEx + skippy) > l {
 19715  				return io.ErrUnexpectedEOF
 19716  			}
 19717  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19718  			iNdEx += skippy
 19719  		}
 19720  	}
 19721  
 19722  	if iNdEx > l {
 19723  		return io.ErrUnexpectedEOF
 19724  	}
 19725  	return nil
 19726  }
 19727  func (m *TabletExternallyReparentedRequest) UnmarshalVT(dAtA []byte) error {
 19728  	l := len(dAtA)
 19729  	iNdEx := 0
 19730  	for iNdEx < l {
 19731  		preIndex := iNdEx
 19732  		var wire uint64
 19733  		for shift := uint(0); ; shift += 7 {
 19734  			if shift >= 64 {
 19735  				return ErrIntOverflow
 19736  			}
 19737  			if iNdEx >= l {
 19738  				return io.ErrUnexpectedEOF
 19739  			}
 19740  			b := dAtA[iNdEx]
 19741  			iNdEx++
 19742  			wire |= uint64(b&0x7F) << shift
 19743  			if b < 0x80 {
 19744  				break
 19745  			}
 19746  		}
 19747  		fieldNum := int32(wire >> 3)
 19748  		wireType := int(wire & 0x7)
 19749  		if wireType == 4 {
 19750  			return fmt.Errorf("proto: TabletExternallyReparentedRequest: wiretype end group for non-group")
 19751  		}
 19752  		if fieldNum <= 0 {
 19753  			return fmt.Errorf("proto: TabletExternallyReparentedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 19754  		}
 19755  		switch fieldNum {
 19756  		case 1:
 19757  			if wireType != 2 {
 19758  				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
 19759  			}
 19760  			var msglen int
 19761  			for shift := uint(0); ; shift += 7 {
 19762  				if shift >= 64 {
 19763  					return ErrIntOverflow
 19764  				}
 19765  				if iNdEx >= l {
 19766  					return io.ErrUnexpectedEOF
 19767  				}
 19768  				b := dAtA[iNdEx]
 19769  				iNdEx++
 19770  				msglen |= int(b&0x7F) << shift
 19771  				if b < 0x80 {
 19772  					break
 19773  				}
 19774  			}
 19775  			if msglen < 0 {
 19776  				return ErrInvalidLength
 19777  			}
 19778  			postIndex := iNdEx + msglen
 19779  			if postIndex < 0 {
 19780  				return ErrInvalidLength
 19781  			}
 19782  			if postIndex > l {
 19783  				return io.ErrUnexpectedEOF
 19784  			}
 19785  			if m.Alias == nil {
 19786  				m.Alias = &topodata.TabletAlias{}
 19787  			}
 19788  			if err := m.Alias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 19789  				return err
 19790  			}
 19791  			iNdEx = postIndex
 19792  		case 2:
 19793  			if wireType != 2 {
 19794  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIds", wireType)
 19795  			}
 19796  			var stringLen uint64
 19797  			for shift := uint(0); ; shift += 7 {
 19798  				if shift >= 64 {
 19799  					return ErrIntOverflow
 19800  				}
 19801  				if iNdEx >= l {
 19802  					return io.ErrUnexpectedEOF
 19803  				}
 19804  				b := dAtA[iNdEx]
 19805  				iNdEx++
 19806  				stringLen |= uint64(b&0x7F) << shift
 19807  				if b < 0x80 {
 19808  					break
 19809  				}
 19810  			}
 19811  			intStringLen := int(stringLen)
 19812  			if intStringLen < 0 {
 19813  				return ErrInvalidLength
 19814  			}
 19815  			postIndex := iNdEx + intStringLen
 19816  			if postIndex < 0 {
 19817  				return ErrInvalidLength
 19818  			}
 19819  			if postIndex > l {
 19820  				return io.ErrUnexpectedEOF
 19821  			}
 19822  			m.ClusterIds = append(m.ClusterIds, string(dAtA[iNdEx:postIndex]))
 19823  			iNdEx = postIndex
 19824  		default:
 19825  			iNdEx = preIndex
 19826  			skippy, err := skip(dAtA[iNdEx:])
 19827  			if err != nil {
 19828  				return err
 19829  			}
 19830  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19831  				return ErrInvalidLength
 19832  			}
 19833  			if (iNdEx + skippy) > l {
 19834  				return io.ErrUnexpectedEOF
 19835  			}
 19836  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19837  			iNdEx += skippy
 19838  		}
 19839  	}
 19840  
 19841  	if iNdEx > l {
 19842  		return io.ErrUnexpectedEOF
 19843  	}
 19844  	return nil
 19845  }
 19846  func (m *ValidateRequest) UnmarshalVT(dAtA []byte) error {
 19847  	l := len(dAtA)
 19848  	iNdEx := 0
 19849  	for iNdEx < l {
 19850  		preIndex := iNdEx
 19851  		var wire uint64
 19852  		for shift := uint(0); ; shift += 7 {
 19853  			if shift >= 64 {
 19854  				return ErrIntOverflow
 19855  			}
 19856  			if iNdEx >= l {
 19857  				return io.ErrUnexpectedEOF
 19858  			}
 19859  			b := dAtA[iNdEx]
 19860  			iNdEx++
 19861  			wire |= uint64(b&0x7F) << shift
 19862  			if b < 0x80 {
 19863  				break
 19864  			}
 19865  		}
 19866  		fieldNum := int32(wire >> 3)
 19867  		wireType := int(wire & 0x7)
 19868  		if wireType == 4 {
 19869  			return fmt.Errorf("proto: ValidateRequest: wiretype end group for non-group")
 19870  		}
 19871  		if fieldNum <= 0 {
 19872  			return fmt.Errorf("proto: ValidateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 19873  		}
 19874  		switch fieldNum {
 19875  		case 1:
 19876  			if wireType != 2 {
 19877  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 19878  			}
 19879  			var stringLen uint64
 19880  			for shift := uint(0); ; shift += 7 {
 19881  				if shift >= 64 {
 19882  					return ErrIntOverflow
 19883  				}
 19884  				if iNdEx >= l {
 19885  					return io.ErrUnexpectedEOF
 19886  				}
 19887  				b := dAtA[iNdEx]
 19888  				iNdEx++
 19889  				stringLen |= uint64(b&0x7F) << shift
 19890  				if b < 0x80 {
 19891  					break
 19892  				}
 19893  			}
 19894  			intStringLen := int(stringLen)
 19895  			if intStringLen < 0 {
 19896  				return ErrInvalidLength
 19897  			}
 19898  			postIndex := iNdEx + intStringLen
 19899  			if postIndex < 0 {
 19900  				return ErrInvalidLength
 19901  			}
 19902  			if postIndex > l {
 19903  				return io.ErrUnexpectedEOF
 19904  			}
 19905  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 19906  			iNdEx = postIndex
 19907  		case 2:
 19908  			if wireType != 0 {
 19909  				return fmt.Errorf("proto: wrong wireType = %d for field PingTablets", wireType)
 19910  			}
 19911  			var v int
 19912  			for shift := uint(0); ; shift += 7 {
 19913  				if shift >= 64 {
 19914  					return ErrIntOverflow
 19915  				}
 19916  				if iNdEx >= l {
 19917  					return io.ErrUnexpectedEOF
 19918  				}
 19919  				b := dAtA[iNdEx]
 19920  				iNdEx++
 19921  				v |= int(b&0x7F) << shift
 19922  				if b < 0x80 {
 19923  					break
 19924  				}
 19925  			}
 19926  			m.PingTablets = bool(v != 0)
 19927  		default:
 19928  			iNdEx = preIndex
 19929  			skippy, err := skip(dAtA[iNdEx:])
 19930  			if err != nil {
 19931  				return err
 19932  			}
 19933  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 19934  				return ErrInvalidLength
 19935  			}
 19936  			if (iNdEx + skippy) > l {
 19937  				return io.ErrUnexpectedEOF
 19938  			}
 19939  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 19940  			iNdEx += skippy
 19941  		}
 19942  	}
 19943  
 19944  	if iNdEx > l {
 19945  		return io.ErrUnexpectedEOF
 19946  	}
 19947  	return nil
 19948  }
 19949  func (m *ValidateKeyspaceRequest) UnmarshalVT(dAtA []byte) error {
 19950  	l := len(dAtA)
 19951  	iNdEx := 0
 19952  	for iNdEx < l {
 19953  		preIndex := iNdEx
 19954  		var wire uint64
 19955  		for shift := uint(0); ; shift += 7 {
 19956  			if shift >= 64 {
 19957  				return ErrIntOverflow
 19958  			}
 19959  			if iNdEx >= l {
 19960  				return io.ErrUnexpectedEOF
 19961  			}
 19962  			b := dAtA[iNdEx]
 19963  			iNdEx++
 19964  			wire |= uint64(b&0x7F) << shift
 19965  			if b < 0x80 {
 19966  				break
 19967  			}
 19968  		}
 19969  		fieldNum := int32(wire >> 3)
 19970  		wireType := int(wire & 0x7)
 19971  		if wireType == 4 {
 19972  			return fmt.Errorf("proto: ValidateKeyspaceRequest: wiretype end group for non-group")
 19973  		}
 19974  		if fieldNum <= 0 {
 19975  			return fmt.Errorf("proto: ValidateKeyspaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 19976  		}
 19977  		switch fieldNum {
 19978  		case 1:
 19979  			if wireType != 2 {
 19980  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 19981  			}
 19982  			var stringLen uint64
 19983  			for shift := uint(0); ; shift += 7 {
 19984  				if shift >= 64 {
 19985  					return ErrIntOverflow
 19986  				}
 19987  				if iNdEx >= l {
 19988  					return io.ErrUnexpectedEOF
 19989  				}
 19990  				b := dAtA[iNdEx]
 19991  				iNdEx++
 19992  				stringLen |= uint64(b&0x7F) << shift
 19993  				if b < 0x80 {
 19994  					break
 19995  				}
 19996  			}
 19997  			intStringLen := int(stringLen)
 19998  			if intStringLen < 0 {
 19999  				return ErrInvalidLength
 20000  			}
 20001  			postIndex := iNdEx + intStringLen
 20002  			if postIndex < 0 {
 20003  				return ErrInvalidLength
 20004  			}
 20005  			if postIndex > l {
 20006  				return io.ErrUnexpectedEOF
 20007  			}
 20008  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 20009  			iNdEx = postIndex
 20010  		case 2:
 20011  			if wireType != 2 {
 20012  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 20013  			}
 20014  			var stringLen uint64
 20015  			for shift := uint(0); ; shift += 7 {
 20016  				if shift >= 64 {
 20017  					return ErrIntOverflow
 20018  				}
 20019  				if iNdEx >= l {
 20020  					return io.ErrUnexpectedEOF
 20021  				}
 20022  				b := dAtA[iNdEx]
 20023  				iNdEx++
 20024  				stringLen |= uint64(b&0x7F) << shift
 20025  				if b < 0x80 {
 20026  					break
 20027  				}
 20028  			}
 20029  			intStringLen := int(stringLen)
 20030  			if intStringLen < 0 {
 20031  				return ErrInvalidLength
 20032  			}
 20033  			postIndex := iNdEx + intStringLen
 20034  			if postIndex < 0 {
 20035  				return ErrInvalidLength
 20036  			}
 20037  			if postIndex > l {
 20038  				return io.ErrUnexpectedEOF
 20039  			}
 20040  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 20041  			iNdEx = postIndex
 20042  		case 3:
 20043  			if wireType != 0 {
 20044  				return fmt.Errorf("proto: wrong wireType = %d for field PingTablets", wireType)
 20045  			}
 20046  			var v int
 20047  			for shift := uint(0); ; shift += 7 {
 20048  				if shift >= 64 {
 20049  					return ErrIntOverflow
 20050  				}
 20051  				if iNdEx >= l {
 20052  					return io.ErrUnexpectedEOF
 20053  				}
 20054  				b := dAtA[iNdEx]
 20055  				iNdEx++
 20056  				v |= int(b&0x7F) << shift
 20057  				if b < 0x80 {
 20058  					break
 20059  				}
 20060  			}
 20061  			m.PingTablets = bool(v != 0)
 20062  		default:
 20063  			iNdEx = preIndex
 20064  			skippy, err := skip(dAtA[iNdEx:])
 20065  			if err != nil {
 20066  				return err
 20067  			}
 20068  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20069  				return ErrInvalidLength
 20070  			}
 20071  			if (iNdEx + skippy) > l {
 20072  				return io.ErrUnexpectedEOF
 20073  			}
 20074  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20075  			iNdEx += skippy
 20076  		}
 20077  	}
 20078  
 20079  	if iNdEx > l {
 20080  		return io.ErrUnexpectedEOF
 20081  	}
 20082  	return nil
 20083  }
 20084  func (m *ValidateSchemaKeyspaceRequest) UnmarshalVT(dAtA []byte) error {
 20085  	l := len(dAtA)
 20086  	iNdEx := 0
 20087  	for iNdEx < l {
 20088  		preIndex := iNdEx
 20089  		var wire uint64
 20090  		for shift := uint(0); ; shift += 7 {
 20091  			if shift >= 64 {
 20092  				return ErrIntOverflow
 20093  			}
 20094  			if iNdEx >= l {
 20095  				return io.ErrUnexpectedEOF
 20096  			}
 20097  			b := dAtA[iNdEx]
 20098  			iNdEx++
 20099  			wire |= uint64(b&0x7F) << shift
 20100  			if b < 0x80 {
 20101  				break
 20102  			}
 20103  		}
 20104  		fieldNum := int32(wire >> 3)
 20105  		wireType := int(wire & 0x7)
 20106  		if wireType == 4 {
 20107  			return fmt.Errorf("proto: ValidateSchemaKeyspaceRequest: wiretype end group for non-group")
 20108  		}
 20109  		if fieldNum <= 0 {
 20110  			return fmt.Errorf("proto: ValidateSchemaKeyspaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 20111  		}
 20112  		switch fieldNum {
 20113  		case 1:
 20114  			if wireType != 2 {
 20115  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 20116  			}
 20117  			var stringLen uint64
 20118  			for shift := uint(0); ; shift += 7 {
 20119  				if shift >= 64 {
 20120  					return ErrIntOverflow
 20121  				}
 20122  				if iNdEx >= l {
 20123  					return io.ErrUnexpectedEOF
 20124  				}
 20125  				b := dAtA[iNdEx]
 20126  				iNdEx++
 20127  				stringLen |= uint64(b&0x7F) << shift
 20128  				if b < 0x80 {
 20129  					break
 20130  				}
 20131  			}
 20132  			intStringLen := int(stringLen)
 20133  			if intStringLen < 0 {
 20134  				return ErrInvalidLength
 20135  			}
 20136  			postIndex := iNdEx + intStringLen
 20137  			if postIndex < 0 {
 20138  				return ErrInvalidLength
 20139  			}
 20140  			if postIndex > l {
 20141  				return io.ErrUnexpectedEOF
 20142  			}
 20143  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 20144  			iNdEx = postIndex
 20145  		case 2:
 20146  			if wireType != 2 {
 20147  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 20148  			}
 20149  			var stringLen uint64
 20150  			for shift := uint(0); ; shift += 7 {
 20151  				if shift >= 64 {
 20152  					return ErrIntOverflow
 20153  				}
 20154  				if iNdEx >= l {
 20155  					return io.ErrUnexpectedEOF
 20156  				}
 20157  				b := dAtA[iNdEx]
 20158  				iNdEx++
 20159  				stringLen |= uint64(b&0x7F) << shift
 20160  				if b < 0x80 {
 20161  					break
 20162  				}
 20163  			}
 20164  			intStringLen := int(stringLen)
 20165  			if intStringLen < 0 {
 20166  				return ErrInvalidLength
 20167  			}
 20168  			postIndex := iNdEx + intStringLen
 20169  			if postIndex < 0 {
 20170  				return ErrInvalidLength
 20171  			}
 20172  			if postIndex > l {
 20173  				return io.ErrUnexpectedEOF
 20174  			}
 20175  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 20176  			iNdEx = postIndex
 20177  		default:
 20178  			iNdEx = preIndex
 20179  			skippy, err := skip(dAtA[iNdEx:])
 20180  			if err != nil {
 20181  				return err
 20182  			}
 20183  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20184  				return ErrInvalidLength
 20185  			}
 20186  			if (iNdEx + skippy) > l {
 20187  				return io.ErrUnexpectedEOF
 20188  			}
 20189  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20190  			iNdEx += skippy
 20191  		}
 20192  	}
 20193  
 20194  	if iNdEx > l {
 20195  		return io.ErrUnexpectedEOF
 20196  	}
 20197  	return nil
 20198  }
 20199  func (m *ValidateShardRequest) UnmarshalVT(dAtA []byte) error {
 20200  	l := len(dAtA)
 20201  	iNdEx := 0
 20202  	for iNdEx < l {
 20203  		preIndex := iNdEx
 20204  		var wire uint64
 20205  		for shift := uint(0); ; shift += 7 {
 20206  			if shift >= 64 {
 20207  				return ErrIntOverflow
 20208  			}
 20209  			if iNdEx >= l {
 20210  				return io.ErrUnexpectedEOF
 20211  			}
 20212  			b := dAtA[iNdEx]
 20213  			iNdEx++
 20214  			wire |= uint64(b&0x7F) << shift
 20215  			if b < 0x80 {
 20216  				break
 20217  			}
 20218  		}
 20219  		fieldNum := int32(wire >> 3)
 20220  		wireType := int(wire & 0x7)
 20221  		if wireType == 4 {
 20222  			return fmt.Errorf("proto: ValidateShardRequest: wiretype end group for non-group")
 20223  		}
 20224  		if fieldNum <= 0 {
 20225  			return fmt.Errorf("proto: ValidateShardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 20226  		}
 20227  		switch fieldNum {
 20228  		case 1:
 20229  			if wireType != 2 {
 20230  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 20231  			}
 20232  			var stringLen uint64
 20233  			for shift := uint(0); ; shift += 7 {
 20234  				if shift >= 64 {
 20235  					return ErrIntOverflow
 20236  				}
 20237  				if iNdEx >= l {
 20238  					return io.ErrUnexpectedEOF
 20239  				}
 20240  				b := dAtA[iNdEx]
 20241  				iNdEx++
 20242  				stringLen |= uint64(b&0x7F) << shift
 20243  				if b < 0x80 {
 20244  					break
 20245  				}
 20246  			}
 20247  			intStringLen := int(stringLen)
 20248  			if intStringLen < 0 {
 20249  				return ErrInvalidLength
 20250  			}
 20251  			postIndex := iNdEx + intStringLen
 20252  			if postIndex < 0 {
 20253  				return ErrInvalidLength
 20254  			}
 20255  			if postIndex > l {
 20256  				return io.ErrUnexpectedEOF
 20257  			}
 20258  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 20259  			iNdEx = postIndex
 20260  		case 2:
 20261  			if wireType != 2 {
 20262  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 20263  			}
 20264  			var stringLen uint64
 20265  			for shift := uint(0); ; shift += 7 {
 20266  				if shift >= 64 {
 20267  					return ErrIntOverflow
 20268  				}
 20269  				if iNdEx >= l {
 20270  					return io.ErrUnexpectedEOF
 20271  				}
 20272  				b := dAtA[iNdEx]
 20273  				iNdEx++
 20274  				stringLen |= uint64(b&0x7F) << shift
 20275  				if b < 0x80 {
 20276  					break
 20277  				}
 20278  			}
 20279  			intStringLen := int(stringLen)
 20280  			if intStringLen < 0 {
 20281  				return ErrInvalidLength
 20282  			}
 20283  			postIndex := iNdEx + intStringLen
 20284  			if postIndex < 0 {
 20285  				return ErrInvalidLength
 20286  			}
 20287  			if postIndex > l {
 20288  				return io.ErrUnexpectedEOF
 20289  			}
 20290  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 20291  			iNdEx = postIndex
 20292  		case 3:
 20293  			if wireType != 2 {
 20294  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 20295  			}
 20296  			var stringLen uint64
 20297  			for shift := uint(0); ; shift += 7 {
 20298  				if shift >= 64 {
 20299  					return ErrIntOverflow
 20300  				}
 20301  				if iNdEx >= l {
 20302  					return io.ErrUnexpectedEOF
 20303  				}
 20304  				b := dAtA[iNdEx]
 20305  				iNdEx++
 20306  				stringLen |= uint64(b&0x7F) << shift
 20307  				if b < 0x80 {
 20308  					break
 20309  				}
 20310  			}
 20311  			intStringLen := int(stringLen)
 20312  			if intStringLen < 0 {
 20313  				return ErrInvalidLength
 20314  			}
 20315  			postIndex := iNdEx + intStringLen
 20316  			if postIndex < 0 {
 20317  				return ErrInvalidLength
 20318  			}
 20319  			if postIndex > l {
 20320  				return io.ErrUnexpectedEOF
 20321  			}
 20322  			m.Shard = string(dAtA[iNdEx:postIndex])
 20323  			iNdEx = postIndex
 20324  		case 4:
 20325  			if wireType != 0 {
 20326  				return fmt.Errorf("proto: wrong wireType = %d for field PingTablets", wireType)
 20327  			}
 20328  			var v int
 20329  			for shift := uint(0); ; shift += 7 {
 20330  				if shift >= 64 {
 20331  					return ErrIntOverflow
 20332  				}
 20333  				if iNdEx >= l {
 20334  					return io.ErrUnexpectedEOF
 20335  				}
 20336  				b := dAtA[iNdEx]
 20337  				iNdEx++
 20338  				v |= int(b&0x7F) << shift
 20339  				if b < 0x80 {
 20340  					break
 20341  				}
 20342  			}
 20343  			m.PingTablets = bool(v != 0)
 20344  		default:
 20345  			iNdEx = preIndex
 20346  			skippy, err := skip(dAtA[iNdEx:])
 20347  			if err != nil {
 20348  				return err
 20349  			}
 20350  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20351  				return ErrInvalidLength
 20352  			}
 20353  			if (iNdEx + skippy) > l {
 20354  				return io.ErrUnexpectedEOF
 20355  			}
 20356  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20357  			iNdEx += skippy
 20358  		}
 20359  	}
 20360  
 20361  	if iNdEx > l {
 20362  		return io.ErrUnexpectedEOF
 20363  	}
 20364  	return nil
 20365  }
 20366  func (m *ValidateVersionKeyspaceRequest) UnmarshalVT(dAtA []byte) error {
 20367  	l := len(dAtA)
 20368  	iNdEx := 0
 20369  	for iNdEx < l {
 20370  		preIndex := iNdEx
 20371  		var wire uint64
 20372  		for shift := uint(0); ; shift += 7 {
 20373  			if shift >= 64 {
 20374  				return ErrIntOverflow
 20375  			}
 20376  			if iNdEx >= l {
 20377  				return io.ErrUnexpectedEOF
 20378  			}
 20379  			b := dAtA[iNdEx]
 20380  			iNdEx++
 20381  			wire |= uint64(b&0x7F) << shift
 20382  			if b < 0x80 {
 20383  				break
 20384  			}
 20385  		}
 20386  		fieldNum := int32(wire >> 3)
 20387  		wireType := int(wire & 0x7)
 20388  		if wireType == 4 {
 20389  			return fmt.Errorf("proto: ValidateVersionKeyspaceRequest: wiretype end group for non-group")
 20390  		}
 20391  		if fieldNum <= 0 {
 20392  			return fmt.Errorf("proto: ValidateVersionKeyspaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 20393  		}
 20394  		switch fieldNum {
 20395  		case 1:
 20396  			if wireType != 2 {
 20397  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 20398  			}
 20399  			var stringLen uint64
 20400  			for shift := uint(0); ; shift += 7 {
 20401  				if shift >= 64 {
 20402  					return ErrIntOverflow
 20403  				}
 20404  				if iNdEx >= l {
 20405  					return io.ErrUnexpectedEOF
 20406  				}
 20407  				b := dAtA[iNdEx]
 20408  				iNdEx++
 20409  				stringLen |= uint64(b&0x7F) << shift
 20410  				if b < 0x80 {
 20411  					break
 20412  				}
 20413  			}
 20414  			intStringLen := int(stringLen)
 20415  			if intStringLen < 0 {
 20416  				return ErrInvalidLength
 20417  			}
 20418  			postIndex := iNdEx + intStringLen
 20419  			if postIndex < 0 {
 20420  				return ErrInvalidLength
 20421  			}
 20422  			if postIndex > l {
 20423  				return io.ErrUnexpectedEOF
 20424  			}
 20425  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 20426  			iNdEx = postIndex
 20427  		case 2:
 20428  			if wireType != 2 {
 20429  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 20430  			}
 20431  			var stringLen uint64
 20432  			for shift := uint(0); ; shift += 7 {
 20433  				if shift >= 64 {
 20434  					return ErrIntOverflow
 20435  				}
 20436  				if iNdEx >= l {
 20437  					return io.ErrUnexpectedEOF
 20438  				}
 20439  				b := dAtA[iNdEx]
 20440  				iNdEx++
 20441  				stringLen |= uint64(b&0x7F) << shift
 20442  				if b < 0x80 {
 20443  					break
 20444  				}
 20445  			}
 20446  			intStringLen := int(stringLen)
 20447  			if intStringLen < 0 {
 20448  				return ErrInvalidLength
 20449  			}
 20450  			postIndex := iNdEx + intStringLen
 20451  			if postIndex < 0 {
 20452  				return ErrInvalidLength
 20453  			}
 20454  			if postIndex > l {
 20455  				return io.ErrUnexpectedEOF
 20456  			}
 20457  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 20458  			iNdEx = postIndex
 20459  		default:
 20460  			iNdEx = preIndex
 20461  			skippy, err := skip(dAtA[iNdEx:])
 20462  			if err != nil {
 20463  				return err
 20464  			}
 20465  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20466  				return ErrInvalidLength
 20467  			}
 20468  			if (iNdEx + skippy) > l {
 20469  				return io.ErrUnexpectedEOF
 20470  			}
 20471  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20472  			iNdEx += skippy
 20473  		}
 20474  	}
 20475  
 20476  	if iNdEx > l {
 20477  		return io.ErrUnexpectedEOF
 20478  	}
 20479  	return nil
 20480  }
 20481  func (m *ValidateVersionShardRequest) UnmarshalVT(dAtA []byte) error {
 20482  	l := len(dAtA)
 20483  	iNdEx := 0
 20484  	for iNdEx < l {
 20485  		preIndex := iNdEx
 20486  		var wire uint64
 20487  		for shift := uint(0); ; shift += 7 {
 20488  			if shift >= 64 {
 20489  				return ErrIntOverflow
 20490  			}
 20491  			if iNdEx >= l {
 20492  				return io.ErrUnexpectedEOF
 20493  			}
 20494  			b := dAtA[iNdEx]
 20495  			iNdEx++
 20496  			wire |= uint64(b&0x7F) << shift
 20497  			if b < 0x80 {
 20498  				break
 20499  			}
 20500  		}
 20501  		fieldNum := int32(wire >> 3)
 20502  		wireType := int(wire & 0x7)
 20503  		if wireType == 4 {
 20504  			return fmt.Errorf("proto: ValidateVersionShardRequest: wiretype end group for non-group")
 20505  		}
 20506  		if fieldNum <= 0 {
 20507  			return fmt.Errorf("proto: ValidateVersionShardRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 20508  		}
 20509  		switch fieldNum {
 20510  		case 1:
 20511  			if wireType != 2 {
 20512  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
 20513  			}
 20514  			var stringLen uint64
 20515  			for shift := uint(0); ; shift += 7 {
 20516  				if shift >= 64 {
 20517  					return ErrIntOverflow
 20518  				}
 20519  				if iNdEx >= l {
 20520  					return io.ErrUnexpectedEOF
 20521  				}
 20522  				b := dAtA[iNdEx]
 20523  				iNdEx++
 20524  				stringLen |= uint64(b&0x7F) << shift
 20525  				if b < 0x80 {
 20526  					break
 20527  				}
 20528  			}
 20529  			intStringLen := int(stringLen)
 20530  			if intStringLen < 0 {
 20531  				return ErrInvalidLength
 20532  			}
 20533  			postIndex := iNdEx + intStringLen
 20534  			if postIndex < 0 {
 20535  				return ErrInvalidLength
 20536  			}
 20537  			if postIndex > l {
 20538  				return io.ErrUnexpectedEOF
 20539  			}
 20540  			m.ClusterId = string(dAtA[iNdEx:postIndex])
 20541  			iNdEx = postIndex
 20542  		case 2:
 20543  			if wireType != 2 {
 20544  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 20545  			}
 20546  			var stringLen uint64
 20547  			for shift := uint(0); ; shift += 7 {
 20548  				if shift >= 64 {
 20549  					return ErrIntOverflow
 20550  				}
 20551  				if iNdEx >= l {
 20552  					return io.ErrUnexpectedEOF
 20553  				}
 20554  				b := dAtA[iNdEx]
 20555  				iNdEx++
 20556  				stringLen |= uint64(b&0x7F) << shift
 20557  				if b < 0x80 {
 20558  					break
 20559  				}
 20560  			}
 20561  			intStringLen := int(stringLen)
 20562  			if intStringLen < 0 {
 20563  				return ErrInvalidLength
 20564  			}
 20565  			postIndex := iNdEx + intStringLen
 20566  			if postIndex < 0 {
 20567  				return ErrInvalidLength
 20568  			}
 20569  			if postIndex > l {
 20570  				return io.ErrUnexpectedEOF
 20571  			}
 20572  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 20573  			iNdEx = postIndex
 20574  		case 3:
 20575  			if wireType != 2 {
 20576  				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
 20577  			}
 20578  			var stringLen uint64
 20579  			for shift := uint(0); ; shift += 7 {
 20580  				if shift >= 64 {
 20581  					return ErrIntOverflow
 20582  				}
 20583  				if iNdEx >= l {
 20584  					return io.ErrUnexpectedEOF
 20585  				}
 20586  				b := dAtA[iNdEx]
 20587  				iNdEx++
 20588  				stringLen |= uint64(b&0x7F) << shift
 20589  				if b < 0x80 {
 20590  					break
 20591  				}
 20592  			}
 20593  			intStringLen := int(stringLen)
 20594  			if intStringLen < 0 {
 20595  				return ErrInvalidLength
 20596  			}
 20597  			postIndex := iNdEx + intStringLen
 20598  			if postIndex < 0 {
 20599  				return ErrInvalidLength
 20600  			}
 20601  			if postIndex > l {
 20602  				return io.ErrUnexpectedEOF
 20603  			}
 20604  			m.Shard = string(dAtA[iNdEx:postIndex])
 20605  			iNdEx = postIndex
 20606  		default:
 20607  			iNdEx = preIndex
 20608  			skippy, err := skip(dAtA[iNdEx:])
 20609  			if err != nil {
 20610  				return err
 20611  			}
 20612  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20613  				return ErrInvalidLength
 20614  			}
 20615  			if (iNdEx + skippy) > l {
 20616  				return io.ErrUnexpectedEOF
 20617  			}
 20618  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20619  			iNdEx += skippy
 20620  		}
 20621  	}
 20622  
 20623  	if iNdEx > l {
 20624  		return io.ErrUnexpectedEOF
 20625  	}
 20626  	return nil
 20627  }
 20628  func (m *VTExplainRequest) UnmarshalVT(dAtA []byte) error {
 20629  	l := len(dAtA)
 20630  	iNdEx := 0
 20631  	for iNdEx < l {
 20632  		preIndex := iNdEx
 20633  		var wire uint64
 20634  		for shift := uint(0); ; shift += 7 {
 20635  			if shift >= 64 {
 20636  				return ErrIntOverflow
 20637  			}
 20638  			if iNdEx >= l {
 20639  				return io.ErrUnexpectedEOF
 20640  			}
 20641  			b := dAtA[iNdEx]
 20642  			iNdEx++
 20643  			wire |= uint64(b&0x7F) << shift
 20644  			if b < 0x80 {
 20645  				break
 20646  			}
 20647  		}
 20648  		fieldNum := int32(wire >> 3)
 20649  		wireType := int(wire & 0x7)
 20650  		if wireType == 4 {
 20651  			return fmt.Errorf("proto: VTExplainRequest: wiretype end group for non-group")
 20652  		}
 20653  		if fieldNum <= 0 {
 20654  			return fmt.Errorf("proto: VTExplainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 20655  		}
 20656  		switch fieldNum {
 20657  		case 1:
 20658  			if wireType != 2 {
 20659  				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
 20660  			}
 20661  			var stringLen uint64
 20662  			for shift := uint(0); ; shift += 7 {
 20663  				if shift >= 64 {
 20664  					return ErrIntOverflow
 20665  				}
 20666  				if iNdEx >= l {
 20667  					return io.ErrUnexpectedEOF
 20668  				}
 20669  				b := dAtA[iNdEx]
 20670  				iNdEx++
 20671  				stringLen |= uint64(b&0x7F) << shift
 20672  				if b < 0x80 {
 20673  					break
 20674  				}
 20675  			}
 20676  			intStringLen := int(stringLen)
 20677  			if intStringLen < 0 {
 20678  				return ErrInvalidLength
 20679  			}
 20680  			postIndex := iNdEx + intStringLen
 20681  			if postIndex < 0 {
 20682  				return ErrInvalidLength
 20683  			}
 20684  			if postIndex > l {
 20685  				return io.ErrUnexpectedEOF
 20686  			}
 20687  			m.Cluster = string(dAtA[iNdEx:postIndex])
 20688  			iNdEx = postIndex
 20689  		case 2:
 20690  			if wireType != 2 {
 20691  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 20692  			}
 20693  			var stringLen uint64
 20694  			for shift := uint(0); ; shift += 7 {
 20695  				if shift >= 64 {
 20696  					return ErrIntOverflow
 20697  				}
 20698  				if iNdEx >= l {
 20699  					return io.ErrUnexpectedEOF
 20700  				}
 20701  				b := dAtA[iNdEx]
 20702  				iNdEx++
 20703  				stringLen |= uint64(b&0x7F) << shift
 20704  				if b < 0x80 {
 20705  					break
 20706  				}
 20707  			}
 20708  			intStringLen := int(stringLen)
 20709  			if intStringLen < 0 {
 20710  				return ErrInvalidLength
 20711  			}
 20712  			postIndex := iNdEx + intStringLen
 20713  			if postIndex < 0 {
 20714  				return ErrInvalidLength
 20715  			}
 20716  			if postIndex > l {
 20717  				return io.ErrUnexpectedEOF
 20718  			}
 20719  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 20720  			iNdEx = postIndex
 20721  		case 3:
 20722  			if wireType != 2 {
 20723  				return fmt.Errorf("proto: wrong wireType = %d for field Sql", wireType)
 20724  			}
 20725  			var stringLen uint64
 20726  			for shift := uint(0); ; shift += 7 {
 20727  				if shift >= 64 {
 20728  					return ErrIntOverflow
 20729  				}
 20730  				if iNdEx >= l {
 20731  					return io.ErrUnexpectedEOF
 20732  				}
 20733  				b := dAtA[iNdEx]
 20734  				iNdEx++
 20735  				stringLen |= uint64(b&0x7F) << shift
 20736  				if b < 0x80 {
 20737  					break
 20738  				}
 20739  			}
 20740  			intStringLen := int(stringLen)
 20741  			if intStringLen < 0 {
 20742  				return ErrInvalidLength
 20743  			}
 20744  			postIndex := iNdEx + intStringLen
 20745  			if postIndex < 0 {
 20746  				return ErrInvalidLength
 20747  			}
 20748  			if postIndex > l {
 20749  				return io.ErrUnexpectedEOF
 20750  			}
 20751  			m.Sql = string(dAtA[iNdEx:postIndex])
 20752  			iNdEx = postIndex
 20753  		default:
 20754  			iNdEx = preIndex
 20755  			skippy, err := skip(dAtA[iNdEx:])
 20756  			if err != nil {
 20757  				return err
 20758  			}
 20759  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20760  				return ErrInvalidLength
 20761  			}
 20762  			if (iNdEx + skippy) > l {
 20763  				return io.ErrUnexpectedEOF
 20764  			}
 20765  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20766  			iNdEx += skippy
 20767  		}
 20768  	}
 20769  
 20770  	if iNdEx > l {
 20771  		return io.ErrUnexpectedEOF
 20772  	}
 20773  	return nil
 20774  }
 20775  func (m *VTExplainResponse) UnmarshalVT(dAtA []byte) error {
 20776  	l := len(dAtA)
 20777  	iNdEx := 0
 20778  	for iNdEx < l {
 20779  		preIndex := iNdEx
 20780  		var wire uint64
 20781  		for shift := uint(0); ; shift += 7 {
 20782  			if shift >= 64 {
 20783  				return ErrIntOverflow
 20784  			}
 20785  			if iNdEx >= l {
 20786  				return io.ErrUnexpectedEOF
 20787  			}
 20788  			b := dAtA[iNdEx]
 20789  			iNdEx++
 20790  			wire |= uint64(b&0x7F) << shift
 20791  			if b < 0x80 {
 20792  				break
 20793  			}
 20794  		}
 20795  		fieldNum := int32(wire >> 3)
 20796  		wireType := int(wire & 0x7)
 20797  		if wireType == 4 {
 20798  			return fmt.Errorf("proto: VTExplainResponse: wiretype end group for non-group")
 20799  		}
 20800  		if fieldNum <= 0 {
 20801  			return fmt.Errorf("proto: VTExplainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 20802  		}
 20803  		switch fieldNum {
 20804  		case 1:
 20805  			if wireType != 2 {
 20806  				return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
 20807  			}
 20808  			var stringLen uint64
 20809  			for shift := uint(0); ; shift += 7 {
 20810  				if shift >= 64 {
 20811  					return ErrIntOverflow
 20812  				}
 20813  				if iNdEx >= l {
 20814  					return io.ErrUnexpectedEOF
 20815  				}
 20816  				b := dAtA[iNdEx]
 20817  				iNdEx++
 20818  				stringLen |= uint64(b&0x7F) << shift
 20819  				if b < 0x80 {
 20820  					break
 20821  				}
 20822  			}
 20823  			intStringLen := int(stringLen)
 20824  			if intStringLen < 0 {
 20825  				return ErrInvalidLength
 20826  			}
 20827  			postIndex := iNdEx + intStringLen
 20828  			if postIndex < 0 {
 20829  				return ErrInvalidLength
 20830  			}
 20831  			if postIndex > l {
 20832  				return io.ErrUnexpectedEOF
 20833  			}
 20834  			m.Response = string(dAtA[iNdEx:postIndex])
 20835  			iNdEx = postIndex
 20836  		default:
 20837  			iNdEx = preIndex
 20838  			skippy, err := skip(dAtA[iNdEx:])
 20839  			if err != nil {
 20840  				return err
 20841  			}
 20842  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 20843  				return ErrInvalidLength
 20844  			}
 20845  			if (iNdEx + skippy) > l {
 20846  				return io.ErrUnexpectedEOF
 20847  			}
 20848  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 20849  			iNdEx += skippy
 20850  		}
 20851  	}
 20852  
 20853  	if iNdEx > l {
 20854  		return io.ErrUnexpectedEOF
 20855  	}
 20856  	return nil
 20857  }
 20858  
 20859  func skip(dAtA []byte) (n int, err error) {
 20860  	l := len(dAtA)
 20861  	iNdEx := 0
 20862  	depth := 0
 20863  	for iNdEx < l {
 20864  		var wire uint64
 20865  		for shift := uint(0); ; shift += 7 {
 20866  			if shift >= 64 {
 20867  				return 0, ErrIntOverflow
 20868  			}
 20869  			if iNdEx >= l {
 20870  				return 0, io.ErrUnexpectedEOF
 20871  			}
 20872  			b := dAtA[iNdEx]
 20873  			iNdEx++
 20874  			wire |= (uint64(b) & 0x7F) << shift
 20875  			if b < 0x80 {
 20876  				break
 20877  			}
 20878  		}
 20879  		wireType := int(wire & 0x7)
 20880  		switch wireType {
 20881  		case 0:
 20882  			for shift := uint(0); ; shift += 7 {
 20883  				if shift >= 64 {
 20884  					return 0, ErrIntOverflow
 20885  				}
 20886  				if iNdEx >= l {
 20887  					return 0, io.ErrUnexpectedEOF
 20888  				}
 20889  				iNdEx++
 20890  				if dAtA[iNdEx-1] < 0x80 {
 20891  					break
 20892  				}
 20893  			}
 20894  		case 1:
 20895  			iNdEx += 8
 20896  		case 2:
 20897  			var length int
 20898  			for shift := uint(0); ; shift += 7 {
 20899  				if shift >= 64 {
 20900  					return 0, ErrIntOverflow
 20901  				}
 20902  				if iNdEx >= l {
 20903  					return 0, io.ErrUnexpectedEOF
 20904  				}
 20905  				b := dAtA[iNdEx]
 20906  				iNdEx++
 20907  				length |= (int(b) & 0x7F) << shift
 20908  				if b < 0x80 {
 20909  					break
 20910  				}
 20911  			}
 20912  			if length < 0 {
 20913  				return 0, ErrInvalidLength
 20914  			}
 20915  			iNdEx += length
 20916  		case 3:
 20917  			depth++
 20918  		case 4:
 20919  			if depth == 0 {
 20920  				return 0, ErrUnexpectedEndOfGroup
 20921  			}
 20922  			depth--
 20923  		case 5:
 20924  			iNdEx += 4
 20925  		default:
 20926  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 20927  		}
 20928  		if iNdEx < 0 {
 20929  			return 0, ErrInvalidLength
 20930  		}
 20931  		if depth == 0 {
 20932  			return iNdEx, nil
 20933  		}
 20934  	}
 20935  	return 0, io.ErrUnexpectedEOF
 20936  }
 20937  
 20938  var (
 20939  	ErrInvalidLength        = fmt.Errorf("proto: negative length found during unmarshaling")
 20940  	ErrIntOverflow          = fmt.Errorf("proto: integer overflow")
 20941  	ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group")
 20942  )