vitess.io/vitess@v0.16.2/go/vt/proto/tabletmanagerdata/tabletmanagerdata_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: tabletmanagerdata.proto
     4  
     5  package tabletmanagerdata
     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  	query "vitess.io/vitess/go/vt/proto/query"
    14  	replicationdata "vitess.io/vitess/go/vt/proto/replicationdata"
    15  	topodata "vitess.io/vitess/go/vt/proto/topodata"
    16  	vtrpc "vitess.io/vitess/go/vt/proto/vtrpc"
    17  	vttime "vitess.io/vitess/go/vt/proto/vttime"
    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 *TableDefinition) 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 *TableDefinition) MarshalToVT(dAtA []byte) (int, error) {
    41  	size := m.SizeVT()
    42  	return m.MarshalToSizedBufferVT(dAtA[:size])
    43  }
    44  
    45  func (m *TableDefinition) 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.Fields) > 0 {
    58  		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
    59  			size, err := m.Fields[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
    60  			if err != nil {
    61  				return 0, err
    62  			}
    63  			i -= size
    64  			i = encodeVarint(dAtA, i, uint64(size))
    65  			i--
    66  			dAtA[i] = 0x42
    67  		}
    68  	}
    69  	if m.RowCount != 0 {
    70  		i = encodeVarint(dAtA, i, uint64(m.RowCount))
    71  		i--
    72  		dAtA[i] = 0x38
    73  	}
    74  	if m.DataLength != 0 {
    75  		i = encodeVarint(dAtA, i, uint64(m.DataLength))
    76  		i--
    77  		dAtA[i] = 0x30
    78  	}
    79  	if len(m.Type) > 0 {
    80  		i -= len(m.Type)
    81  		copy(dAtA[i:], m.Type)
    82  		i = encodeVarint(dAtA, i, uint64(len(m.Type)))
    83  		i--
    84  		dAtA[i] = 0x2a
    85  	}
    86  	if len(m.PrimaryKeyColumns) > 0 {
    87  		for iNdEx := len(m.PrimaryKeyColumns) - 1; iNdEx >= 0; iNdEx-- {
    88  			i -= len(m.PrimaryKeyColumns[iNdEx])
    89  			copy(dAtA[i:], m.PrimaryKeyColumns[iNdEx])
    90  			i = encodeVarint(dAtA, i, uint64(len(m.PrimaryKeyColumns[iNdEx])))
    91  			i--
    92  			dAtA[i] = 0x22
    93  		}
    94  	}
    95  	if len(m.Columns) > 0 {
    96  		for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- {
    97  			i -= len(m.Columns[iNdEx])
    98  			copy(dAtA[i:], m.Columns[iNdEx])
    99  			i = encodeVarint(dAtA, i, uint64(len(m.Columns[iNdEx])))
   100  			i--
   101  			dAtA[i] = 0x1a
   102  		}
   103  	}
   104  	if len(m.Schema) > 0 {
   105  		i -= len(m.Schema)
   106  		copy(dAtA[i:], m.Schema)
   107  		i = encodeVarint(dAtA, i, uint64(len(m.Schema)))
   108  		i--
   109  		dAtA[i] = 0x12
   110  	}
   111  	if len(m.Name) > 0 {
   112  		i -= len(m.Name)
   113  		copy(dAtA[i:], m.Name)
   114  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
   115  		i--
   116  		dAtA[i] = 0xa
   117  	}
   118  	return len(dAtA) - i, nil
   119  }
   120  
   121  func (m *SchemaDefinition) MarshalVT() (dAtA []byte, err error) {
   122  	if m == nil {
   123  		return nil, nil
   124  	}
   125  	size := m.SizeVT()
   126  	dAtA = make([]byte, size)
   127  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   128  	if err != nil {
   129  		return nil, err
   130  	}
   131  	return dAtA[:n], nil
   132  }
   133  
   134  func (m *SchemaDefinition) MarshalToVT(dAtA []byte) (int, error) {
   135  	size := m.SizeVT()
   136  	return m.MarshalToSizedBufferVT(dAtA[:size])
   137  }
   138  
   139  func (m *SchemaDefinition) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   140  	if m == nil {
   141  		return 0, nil
   142  	}
   143  	i := len(dAtA)
   144  	_ = i
   145  	var l int
   146  	_ = l
   147  	if m.unknownFields != nil {
   148  		i -= len(m.unknownFields)
   149  		copy(dAtA[i:], m.unknownFields)
   150  	}
   151  	if len(m.Version) > 0 {
   152  		i -= len(m.Version)
   153  		copy(dAtA[i:], m.Version)
   154  		i = encodeVarint(dAtA, i, uint64(len(m.Version)))
   155  		i--
   156  		dAtA[i] = 0x1a
   157  	}
   158  	if len(m.TableDefinitions) > 0 {
   159  		for iNdEx := len(m.TableDefinitions) - 1; iNdEx >= 0; iNdEx-- {
   160  			size, err := m.TableDefinitions[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   161  			if err != nil {
   162  				return 0, err
   163  			}
   164  			i -= size
   165  			i = encodeVarint(dAtA, i, uint64(size))
   166  			i--
   167  			dAtA[i] = 0x12
   168  		}
   169  	}
   170  	if len(m.DatabaseSchema) > 0 {
   171  		i -= len(m.DatabaseSchema)
   172  		copy(dAtA[i:], m.DatabaseSchema)
   173  		i = encodeVarint(dAtA, i, uint64(len(m.DatabaseSchema)))
   174  		i--
   175  		dAtA[i] = 0xa
   176  	}
   177  	return len(dAtA) - i, nil
   178  }
   179  
   180  func (m *SchemaChangeResult) MarshalVT() (dAtA []byte, err error) {
   181  	if m == nil {
   182  		return nil, nil
   183  	}
   184  	size := m.SizeVT()
   185  	dAtA = make([]byte, size)
   186  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   187  	if err != nil {
   188  		return nil, err
   189  	}
   190  	return dAtA[:n], nil
   191  }
   192  
   193  func (m *SchemaChangeResult) MarshalToVT(dAtA []byte) (int, error) {
   194  	size := m.SizeVT()
   195  	return m.MarshalToSizedBufferVT(dAtA[:size])
   196  }
   197  
   198  func (m *SchemaChangeResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   199  	if m == nil {
   200  		return 0, nil
   201  	}
   202  	i := len(dAtA)
   203  	_ = i
   204  	var l int
   205  	_ = l
   206  	if m.unknownFields != nil {
   207  		i -= len(m.unknownFields)
   208  		copy(dAtA[i:], m.unknownFields)
   209  	}
   210  	if m.AfterSchema != nil {
   211  		size, err := m.AfterSchema.MarshalToSizedBufferVT(dAtA[:i])
   212  		if err != nil {
   213  			return 0, err
   214  		}
   215  		i -= size
   216  		i = encodeVarint(dAtA, i, uint64(size))
   217  		i--
   218  		dAtA[i] = 0x12
   219  	}
   220  	if m.BeforeSchema != nil {
   221  		size, err := m.BeforeSchema.MarshalToSizedBufferVT(dAtA[:i])
   222  		if err != nil {
   223  			return 0, err
   224  		}
   225  		i -= size
   226  		i = encodeVarint(dAtA, i, uint64(size))
   227  		i--
   228  		dAtA[i] = 0xa
   229  	}
   230  	return len(dAtA) - i, nil
   231  }
   232  
   233  func (m *UserPermission) MarshalVT() (dAtA []byte, err error) {
   234  	if m == nil {
   235  		return nil, nil
   236  	}
   237  	size := m.SizeVT()
   238  	dAtA = make([]byte, size)
   239  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   240  	if err != nil {
   241  		return nil, err
   242  	}
   243  	return dAtA[:n], nil
   244  }
   245  
   246  func (m *UserPermission) MarshalToVT(dAtA []byte) (int, error) {
   247  	size := m.SizeVT()
   248  	return m.MarshalToSizedBufferVT(dAtA[:size])
   249  }
   250  
   251  func (m *UserPermission) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   252  	if m == nil {
   253  		return 0, nil
   254  	}
   255  	i := len(dAtA)
   256  	_ = i
   257  	var l int
   258  	_ = l
   259  	if m.unknownFields != nil {
   260  		i -= len(m.unknownFields)
   261  		copy(dAtA[i:], m.unknownFields)
   262  	}
   263  	if len(m.Privileges) > 0 {
   264  		for k := range m.Privileges {
   265  			v := m.Privileges[k]
   266  			baseI := i
   267  			i -= len(v)
   268  			copy(dAtA[i:], v)
   269  			i = encodeVarint(dAtA, i, uint64(len(v)))
   270  			i--
   271  			dAtA[i] = 0x12
   272  			i -= len(k)
   273  			copy(dAtA[i:], k)
   274  			i = encodeVarint(dAtA, i, uint64(len(k)))
   275  			i--
   276  			dAtA[i] = 0xa
   277  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   278  			i--
   279  			dAtA[i] = 0x22
   280  		}
   281  	}
   282  	if m.PasswordChecksum != 0 {
   283  		i = encodeVarint(dAtA, i, uint64(m.PasswordChecksum))
   284  		i--
   285  		dAtA[i] = 0x18
   286  	}
   287  	if len(m.User) > 0 {
   288  		i -= len(m.User)
   289  		copy(dAtA[i:], m.User)
   290  		i = encodeVarint(dAtA, i, uint64(len(m.User)))
   291  		i--
   292  		dAtA[i] = 0x12
   293  	}
   294  	if len(m.Host) > 0 {
   295  		i -= len(m.Host)
   296  		copy(dAtA[i:], m.Host)
   297  		i = encodeVarint(dAtA, i, uint64(len(m.Host)))
   298  		i--
   299  		dAtA[i] = 0xa
   300  	}
   301  	return len(dAtA) - i, nil
   302  }
   303  
   304  func (m *DbPermission) MarshalVT() (dAtA []byte, err error) {
   305  	if m == nil {
   306  		return nil, nil
   307  	}
   308  	size := m.SizeVT()
   309  	dAtA = make([]byte, size)
   310  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   311  	if err != nil {
   312  		return nil, err
   313  	}
   314  	return dAtA[:n], nil
   315  }
   316  
   317  func (m *DbPermission) MarshalToVT(dAtA []byte) (int, error) {
   318  	size := m.SizeVT()
   319  	return m.MarshalToSizedBufferVT(dAtA[:size])
   320  }
   321  
   322  func (m *DbPermission) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   323  	if m == nil {
   324  		return 0, nil
   325  	}
   326  	i := len(dAtA)
   327  	_ = i
   328  	var l int
   329  	_ = l
   330  	if m.unknownFields != nil {
   331  		i -= len(m.unknownFields)
   332  		copy(dAtA[i:], m.unknownFields)
   333  	}
   334  	if len(m.Privileges) > 0 {
   335  		for k := range m.Privileges {
   336  			v := m.Privileges[k]
   337  			baseI := i
   338  			i -= len(v)
   339  			copy(dAtA[i:], v)
   340  			i = encodeVarint(dAtA, i, uint64(len(v)))
   341  			i--
   342  			dAtA[i] = 0x12
   343  			i -= len(k)
   344  			copy(dAtA[i:], k)
   345  			i = encodeVarint(dAtA, i, uint64(len(k)))
   346  			i--
   347  			dAtA[i] = 0xa
   348  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   349  			i--
   350  			dAtA[i] = 0x22
   351  		}
   352  	}
   353  	if len(m.User) > 0 {
   354  		i -= len(m.User)
   355  		copy(dAtA[i:], m.User)
   356  		i = encodeVarint(dAtA, i, uint64(len(m.User)))
   357  		i--
   358  		dAtA[i] = 0x1a
   359  	}
   360  	if len(m.Db) > 0 {
   361  		i -= len(m.Db)
   362  		copy(dAtA[i:], m.Db)
   363  		i = encodeVarint(dAtA, i, uint64(len(m.Db)))
   364  		i--
   365  		dAtA[i] = 0x12
   366  	}
   367  	if len(m.Host) > 0 {
   368  		i -= len(m.Host)
   369  		copy(dAtA[i:], m.Host)
   370  		i = encodeVarint(dAtA, i, uint64(len(m.Host)))
   371  		i--
   372  		dAtA[i] = 0xa
   373  	}
   374  	return len(dAtA) - i, nil
   375  }
   376  
   377  func (m *Permissions) MarshalVT() (dAtA []byte, err error) {
   378  	if m == nil {
   379  		return nil, nil
   380  	}
   381  	size := m.SizeVT()
   382  	dAtA = make([]byte, size)
   383  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   384  	if err != nil {
   385  		return nil, err
   386  	}
   387  	return dAtA[:n], nil
   388  }
   389  
   390  func (m *Permissions) MarshalToVT(dAtA []byte) (int, error) {
   391  	size := m.SizeVT()
   392  	return m.MarshalToSizedBufferVT(dAtA[:size])
   393  }
   394  
   395  func (m *Permissions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   396  	if m == nil {
   397  		return 0, nil
   398  	}
   399  	i := len(dAtA)
   400  	_ = i
   401  	var l int
   402  	_ = l
   403  	if m.unknownFields != nil {
   404  		i -= len(m.unknownFields)
   405  		copy(dAtA[i:], m.unknownFields)
   406  	}
   407  	if len(m.DbPermissions) > 0 {
   408  		for iNdEx := len(m.DbPermissions) - 1; iNdEx >= 0; iNdEx-- {
   409  			size, err := m.DbPermissions[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   410  			if err != nil {
   411  				return 0, err
   412  			}
   413  			i -= size
   414  			i = encodeVarint(dAtA, i, uint64(size))
   415  			i--
   416  			dAtA[i] = 0x12
   417  		}
   418  	}
   419  	if len(m.UserPermissions) > 0 {
   420  		for iNdEx := len(m.UserPermissions) - 1; iNdEx >= 0; iNdEx-- {
   421  			size, err := m.UserPermissions[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
   422  			if err != nil {
   423  				return 0, err
   424  			}
   425  			i -= size
   426  			i = encodeVarint(dAtA, i, uint64(size))
   427  			i--
   428  			dAtA[i] = 0xa
   429  		}
   430  	}
   431  	return len(dAtA) - i, nil
   432  }
   433  
   434  func (m *PingRequest) MarshalVT() (dAtA []byte, err error) {
   435  	if m == nil {
   436  		return nil, nil
   437  	}
   438  	size := m.SizeVT()
   439  	dAtA = make([]byte, size)
   440  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   441  	if err != nil {
   442  		return nil, err
   443  	}
   444  	return dAtA[:n], nil
   445  }
   446  
   447  func (m *PingRequest) MarshalToVT(dAtA []byte) (int, error) {
   448  	size := m.SizeVT()
   449  	return m.MarshalToSizedBufferVT(dAtA[:size])
   450  }
   451  
   452  func (m *PingRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   453  	if m == nil {
   454  		return 0, nil
   455  	}
   456  	i := len(dAtA)
   457  	_ = i
   458  	var l int
   459  	_ = l
   460  	if m.unknownFields != nil {
   461  		i -= len(m.unknownFields)
   462  		copy(dAtA[i:], m.unknownFields)
   463  	}
   464  	if len(m.Payload) > 0 {
   465  		i -= len(m.Payload)
   466  		copy(dAtA[i:], m.Payload)
   467  		i = encodeVarint(dAtA, i, uint64(len(m.Payload)))
   468  		i--
   469  		dAtA[i] = 0xa
   470  	}
   471  	return len(dAtA) - i, nil
   472  }
   473  
   474  func (m *PingResponse) MarshalVT() (dAtA []byte, err error) {
   475  	if m == nil {
   476  		return nil, nil
   477  	}
   478  	size := m.SizeVT()
   479  	dAtA = make([]byte, size)
   480  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   481  	if err != nil {
   482  		return nil, err
   483  	}
   484  	return dAtA[:n], nil
   485  }
   486  
   487  func (m *PingResponse) MarshalToVT(dAtA []byte) (int, error) {
   488  	size := m.SizeVT()
   489  	return m.MarshalToSizedBufferVT(dAtA[:size])
   490  }
   491  
   492  func (m *PingResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   493  	if m == nil {
   494  		return 0, nil
   495  	}
   496  	i := len(dAtA)
   497  	_ = i
   498  	var l int
   499  	_ = l
   500  	if m.unknownFields != nil {
   501  		i -= len(m.unknownFields)
   502  		copy(dAtA[i:], m.unknownFields)
   503  	}
   504  	if len(m.Payload) > 0 {
   505  		i -= len(m.Payload)
   506  		copy(dAtA[i:], m.Payload)
   507  		i = encodeVarint(dAtA, i, uint64(len(m.Payload)))
   508  		i--
   509  		dAtA[i] = 0xa
   510  	}
   511  	return len(dAtA) - i, nil
   512  }
   513  
   514  func (m *SleepRequest) MarshalVT() (dAtA []byte, err error) {
   515  	if m == nil {
   516  		return nil, nil
   517  	}
   518  	size := m.SizeVT()
   519  	dAtA = make([]byte, size)
   520  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   521  	if err != nil {
   522  		return nil, err
   523  	}
   524  	return dAtA[:n], nil
   525  }
   526  
   527  func (m *SleepRequest) MarshalToVT(dAtA []byte) (int, error) {
   528  	size := m.SizeVT()
   529  	return m.MarshalToSizedBufferVT(dAtA[:size])
   530  }
   531  
   532  func (m *SleepRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   533  	if m == nil {
   534  		return 0, nil
   535  	}
   536  	i := len(dAtA)
   537  	_ = i
   538  	var l int
   539  	_ = l
   540  	if m.unknownFields != nil {
   541  		i -= len(m.unknownFields)
   542  		copy(dAtA[i:], m.unknownFields)
   543  	}
   544  	if m.Duration != 0 {
   545  		i = encodeVarint(dAtA, i, uint64(m.Duration))
   546  		i--
   547  		dAtA[i] = 0x8
   548  	}
   549  	return len(dAtA) - i, nil
   550  }
   551  
   552  func (m *SleepResponse) MarshalVT() (dAtA []byte, err error) {
   553  	if m == nil {
   554  		return nil, nil
   555  	}
   556  	size := m.SizeVT()
   557  	dAtA = make([]byte, size)
   558  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   559  	if err != nil {
   560  		return nil, err
   561  	}
   562  	return dAtA[:n], nil
   563  }
   564  
   565  func (m *SleepResponse) MarshalToVT(dAtA []byte) (int, error) {
   566  	size := m.SizeVT()
   567  	return m.MarshalToSizedBufferVT(dAtA[:size])
   568  }
   569  
   570  func (m *SleepResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   571  	if m == nil {
   572  		return 0, nil
   573  	}
   574  	i := len(dAtA)
   575  	_ = i
   576  	var l int
   577  	_ = l
   578  	if m.unknownFields != nil {
   579  		i -= len(m.unknownFields)
   580  		copy(dAtA[i:], m.unknownFields)
   581  	}
   582  	return len(dAtA) - i, nil
   583  }
   584  
   585  func (m *ExecuteHookRequest) MarshalVT() (dAtA []byte, err error) {
   586  	if m == nil {
   587  		return nil, nil
   588  	}
   589  	size := m.SizeVT()
   590  	dAtA = make([]byte, size)
   591  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   592  	if err != nil {
   593  		return nil, err
   594  	}
   595  	return dAtA[:n], nil
   596  }
   597  
   598  func (m *ExecuteHookRequest) MarshalToVT(dAtA []byte) (int, error) {
   599  	size := m.SizeVT()
   600  	return m.MarshalToSizedBufferVT(dAtA[:size])
   601  }
   602  
   603  func (m *ExecuteHookRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   604  	if m == nil {
   605  		return 0, nil
   606  	}
   607  	i := len(dAtA)
   608  	_ = i
   609  	var l int
   610  	_ = l
   611  	if m.unknownFields != nil {
   612  		i -= len(m.unknownFields)
   613  		copy(dAtA[i:], m.unknownFields)
   614  	}
   615  	if len(m.ExtraEnv) > 0 {
   616  		for k := range m.ExtraEnv {
   617  			v := m.ExtraEnv[k]
   618  			baseI := i
   619  			i -= len(v)
   620  			copy(dAtA[i:], v)
   621  			i = encodeVarint(dAtA, i, uint64(len(v)))
   622  			i--
   623  			dAtA[i] = 0x12
   624  			i -= len(k)
   625  			copy(dAtA[i:], k)
   626  			i = encodeVarint(dAtA, i, uint64(len(k)))
   627  			i--
   628  			dAtA[i] = 0xa
   629  			i = encodeVarint(dAtA, i, uint64(baseI-i))
   630  			i--
   631  			dAtA[i] = 0x1a
   632  		}
   633  	}
   634  	if len(m.Parameters) > 0 {
   635  		for iNdEx := len(m.Parameters) - 1; iNdEx >= 0; iNdEx-- {
   636  			i -= len(m.Parameters[iNdEx])
   637  			copy(dAtA[i:], m.Parameters[iNdEx])
   638  			i = encodeVarint(dAtA, i, uint64(len(m.Parameters[iNdEx])))
   639  			i--
   640  			dAtA[i] = 0x12
   641  		}
   642  	}
   643  	if len(m.Name) > 0 {
   644  		i -= len(m.Name)
   645  		copy(dAtA[i:], m.Name)
   646  		i = encodeVarint(dAtA, i, uint64(len(m.Name)))
   647  		i--
   648  		dAtA[i] = 0xa
   649  	}
   650  	return len(dAtA) - i, nil
   651  }
   652  
   653  func (m *ExecuteHookResponse) MarshalVT() (dAtA []byte, err error) {
   654  	if m == nil {
   655  		return nil, nil
   656  	}
   657  	size := m.SizeVT()
   658  	dAtA = make([]byte, size)
   659  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   660  	if err != nil {
   661  		return nil, err
   662  	}
   663  	return dAtA[:n], nil
   664  }
   665  
   666  func (m *ExecuteHookResponse) MarshalToVT(dAtA []byte) (int, error) {
   667  	size := m.SizeVT()
   668  	return m.MarshalToSizedBufferVT(dAtA[:size])
   669  }
   670  
   671  func (m *ExecuteHookResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   672  	if m == nil {
   673  		return 0, nil
   674  	}
   675  	i := len(dAtA)
   676  	_ = i
   677  	var l int
   678  	_ = l
   679  	if m.unknownFields != nil {
   680  		i -= len(m.unknownFields)
   681  		copy(dAtA[i:], m.unknownFields)
   682  	}
   683  	if len(m.Stderr) > 0 {
   684  		i -= len(m.Stderr)
   685  		copy(dAtA[i:], m.Stderr)
   686  		i = encodeVarint(dAtA, i, uint64(len(m.Stderr)))
   687  		i--
   688  		dAtA[i] = 0x1a
   689  	}
   690  	if len(m.Stdout) > 0 {
   691  		i -= len(m.Stdout)
   692  		copy(dAtA[i:], m.Stdout)
   693  		i = encodeVarint(dAtA, i, uint64(len(m.Stdout)))
   694  		i--
   695  		dAtA[i] = 0x12
   696  	}
   697  	if m.ExitStatus != 0 {
   698  		i = encodeVarint(dAtA, i, uint64(m.ExitStatus))
   699  		i--
   700  		dAtA[i] = 0x8
   701  	}
   702  	return len(dAtA) - i, nil
   703  }
   704  
   705  func (m *GetSchemaRequest) MarshalVT() (dAtA []byte, err error) {
   706  	if m == nil {
   707  		return nil, nil
   708  	}
   709  	size := m.SizeVT()
   710  	dAtA = make([]byte, size)
   711  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   712  	if err != nil {
   713  		return nil, err
   714  	}
   715  	return dAtA[:n], nil
   716  }
   717  
   718  func (m *GetSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
   719  	size := m.SizeVT()
   720  	return m.MarshalToSizedBufferVT(dAtA[:size])
   721  }
   722  
   723  func (m *GetSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   724  	if m == nil {
   725  		return 0, nil
   726  	}
   727  	i := len(dAtA)
   728  	_ = i
   729  	var l int
   730  	_ = l
   731  	if m.unknownFields != nil {
   732  		i -= len(m.unknownFields)
   733  		copy(dAtA[i:], m.unknownFields)
   734  	}
   735  	if m.TableSchemaOnly {
   736  		i--
   737  		if m.TableSchemaOnly {
   738  			dAtA[i] = 1
   739  		} else {
   740  			dAtA[i] = 0
   741  		}
   742  		i--
   743  		dAtA[i] = 0x20
   744  	}
   745  	if len(m.ExcludeTables) > 0 {
   746  		for iNdEx := len(m.ExcludeTables) - 1; iNdEx >= 0; iNdEx-- {
   747  			i -= len(m.ExcludeTables[iNdEx])
   748  			copy(dAtA[i:], m.ExcludeTables[iNdEx])
   749  			i = encodeVarint(dAtA, i, uint64(len(m.ExcludeTables[iNdEx])))
   750  			i--
   751  			dAtA[i] = 0x1a
   752  		}
   753  	}
   754  	if m.IncludeViews {
   755  		i--
   756  		if m.IncludeViews {
   757  			dAtA[i] = 1
   758  		} else {
   759  			dAtA[i] = 0
   760  		}
   761  		i--
   762  		dAtA[i] = 0x10
   763  	}
   764  	if len(m.Tables) > 0 {
   765  		for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- {
   766  			i -= len(m.Tables[iNdEx])
   767  			copy(dAtA[i:], m.Tables[iNdEx])
   768  			i = encodeVarint(dAtA, i, uint64(len(m.Tables[iNdEx])))
   769  			i--
   770  			dAtA[i] = 0xa
   771  		}
   772  	}
   773  	return len(dAtA) - i, nil
   774  }
   775  
   776  func (m *GetSchemaResponse) MarshalVT() (dAtA []byte, err error) {
   777  	if m == nil {
   778  		return nil, nil
   779  	}
   780  	size := m.SizeVT()
   781  	dAtA = make([]byte, size)
   782  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   783  	if err != nil {
   784  		return nil, err
   785  	}
   786  	return dAtA[:n], nil
   787  }
   788  
   789  func (m *GetSchemaResponse) MarshalToVT(dAtA []byte) (int, error) {
   790  	size := m.SizeVT()
   791  	return m.MarshalToSizedBufferVT(dAtA[:size])
   792  }
   793  
   794  func (m *GetSchemaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   795  	if m == nil {
   796  		return 0, nil
   797  	}
   798  	i := len(dAtA)
   799  	_ = i
   800  	var l int
   801  	_ = l
   802  	if m.unknownFields != nil {
   803  		i -= len(m.unknownFields)
   804  		copy(dAtA[i:], m.unknownFields)
   805  	}
   806  	if m.SchemaDefinition != nil {
   807  		size, err := m.SchemaDefinition.MarshalToSizedBufferVT(dAtA[:i])
   808  		if err != nil {
   809  			return 0, err
   810  		}
   811  		i -= size
   812  		i = encodeVarint(dAtA, i, uint64(size))
   813  		i--
   814  		dAtA[i] = 0xa
   815  	}
   816  	return len(dAtA) - i, nil
   817  }
   818  
   819  func (m *GetPermissionsRequest) MarshalVT() (dAtA []byte, err error) {
   820  	if m == nil {
   821  		return nil, nil
   822  	}
   823  	size := m.SizeVT()
   824  	dAtA = make([]byte, size)
   825  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   826  	if err != nil {
   827  		return nil, err
   828  	}
   829  	return dAtA[:n], nil
   830  }
   831  
   832  func (m *GetPermissionsRequest) MarshalToVT(dAtA []byte) (int, error) {
   833  	size := m.SizeVT()
   834  	return m.MarshalToSizedBufferVT(dAtA[:size])
   835  }
   836  
   837  func (m *GetPermissionsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   838  	if m == nil {
   839  		return 0, nil
   840  	}
   841  	i := len(dAtA)
   842  	_ = i
   843  	var l int
   844  	_ = l
   845  	if m.unknownFields != nil {
   846  		i -= len(m.unknownFields)
   847  		copy(dAtA[i:], m.unknownFields)
   848  	}
   849  	return len(dAtA) - i, nil
   850  }
   851  
   852  func (m *GetPermissionsResponse) MarshalVT() (dAtA []byte, err error) {
   853  	if m == nil {
   854  		return nil, nil
   855  	}
   856  	size := m.SizeVT()
   857  	dAtA = make([]byte, size)
   858  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   859  	if err != nil {
   860  		return nil, err
   861  	}
   862  	return dAtA[:n], nil
   863  }
   864  
   865  func (m *GetPermissionsResponse) MarshalToVT(dAtA []byte) (int, error) {
   866  	size := m.SizeVT()
   867  	return m.MarshalToSizedBufferVT(dAtA[:size])
   868  }
   869  
   870  func (m *GetPermissionsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   871  	if m == nil {
   872  		return 0, nil
   873  	}
   874  	i := len(dAtA)
   875  	_ = i
   876  	var l int
   877  	_ = l
   878  	if m.unknownFields != nil {
   879  		i -= len(m.unknownFields)
   880  		copy(dAtA[i:], m.unknownFields)
   881  	}
   882  	if m.Permissions != nil {
   883  		size, err := m.Permissions.MarshalToSizedBufferVT(dAtA[:i])
   884  		if err != nil {
   885  			return 0, err
   886  		}
   887  		i -= size
   888  		i = encodeVarint(dAtA, i, uint64(size))
   889  		i--
   890  		dAtA[i] = 0xa
   891  	}
   892  	return len(dAtA) - i, nil
   893  }
   894  
   895  func (m *SetReadOnlyRequest) MarshalVT() (dAtA []byte, err error) {
   896  	if m == nil {
   897  		return nil, nil
   898  	}
   899  	size := m.SizeVT()
   900  	dAtA = make([]byte, size)
   901  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   902  	if err != nil {
   903  		return nil, err
   904  	}
   905  	return dAtA[:n], nil
   906  }
   907  
   908  func (m *SetReadOnlyRequest) MarshalToVT(dAtA []byte) (int, error) {
   909  	size := m.SizeVT()
   910  	return m.MarshalToSizedBufferVT(dAtA[:size])
   911  }
   912  
   913  func (m *SetReadOnlyRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   914  	if m == nil {
   915  		return 0, nil
   916  	}
   917  	i := len(dAtA)
   918  	_ = i
   919  	var l int
   920  	_ = l
   921  	if m.unknownFields != nil {
   922  		i -= len(m.unknownFields)
   923  		copy(dAtA[i:], m.unknownFields)
   924  	}
   925  	return len(dAtA) - i, nil
   926  }
   927  
   928  func (m *SetReadOnlyResponse) MarshalVT() (dAtA []byte, err error) {
   929  	if m == nil {
   930  		return nil, nil
   931  	}
   932  	size := m.SizeVT()
   933  	dAtA = make([]byte, size)
   934  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   935  	if err != nil {
   936  		return nil, err
   937  	}
   938  	return dAtA[:n], nil
   939  }
   940  
   941  func (m *SetReadOnlyResponse) MarshalToVT(dAtA []byte) (int, error) {
   942  	size := m.SizeVT()
   943  	return m.MarshalToSizedBufferVT(dAtA[:size])
   944  }
   945  
   946  func (m *SetReadOnlyResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   947  	if m == nil {
   948  		return 0, nil
   949  	}
   950  	i := len(dAtA)
   951  	_ = i
   952  	var l int
   953  	_ = l
   954  	if m.unknownFields != nil {
   955  		i -= len(m.unknownFields)
   956  		copy(dAtA[i:], m.unknownFields)
   957  	}
   958  	return len(dAtA) - i, nil
   959  }
   960  
   961  func (m *SetReadWriteRequest) MarshalVT() (dAtA []byte, err error) {
   962  	if m == nil {
   963  		return nil, nil
   964  	}
   965  	size := m.SizeVT()
   966  	dAtA = make([]byte, size)
   967  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
   968  	if err != nil {
   969  		return nil, err
   970  	}
   971  	return dAtA[:n], nil
   972  }
   973  
   974  func (m *SetReadWriteRequest) MarshalToVT(dAtA []byte) (int, error) {
   975  	size := m.SizeVT()
   976  	return m.MarshalToSizedBufferVT(dAtA[:size])
   977  }
   978  
   979  func (m *SetReadWriteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
   980  	if m == nil {
   981  		return 0, nil
   982  	}
   983  	i := len(dAtA)
   984  	_ = i
   985  	var l int
   986  	_ = l
   987  	if m.unknownFields != nil {
   988  		i -= len(m.unknownFields)
   989  		copy(dAtA[i:], m.unknownFields)
   990  	}
   991  	return len(dAtA) - i, nil
   992  }
   993  
   994  func (m *SetReadWriteResponse) MarshalVT() (dAtA []byte, err error) {
   995  	if m == nil {
   996  		return nil, nil
   997  	}
   998  	size := m.SizeVT()
   999  	dAtA = make([]byte, size)
  1000  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1001  	if err != nil {
  1002  		return nil, err
  1003  	}
  1004  	return dAtA[:n], nil
  1005  }
  1006  
  1007  func (m *SetReadWriteResponse) MarshalToVT(dAtA []byte) (int, error) {
  1008  	size := m.SizeVT()
  1009  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1010  }
  1011  
  1012  func (m *SetReadWriteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1013  	if m == nil {
  1014  		return 0, nil
  1015  	}
  1016  	i := len(dAtA)
  1017  	_ = i
  1018  	var l int
  1019  	_ = l
  1020  	if m.unknownFields != nil {
  1021  		i -= len(m.unknownFields)
  1022  		copy(dAtA[i:], m.unknownFields)
  1023  	}
  1024  	return len(dAtA) - i, nil
  1025  }
  1026  
  1027  func (m *ChangeTypeRequest) MarshalVT() (dAtA []byte, err error) {
  1028  	if m == nil {
  1029  		return nil, nil
  1030  	}
  1031  	size := m.SizeVT()
  1032  	dAtA = make([]byte, size)
  1033  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1034  	if err != nil {
  1035  		return nil, err
  1036  	}
  1037  	return dAtA[:n], nil
  1038  }
  1039  
  1040  func (m *ChangeTypeRequest) MarshalToVT(dAtA []byte) (int, error) {
  1041  	size := m.SizeVT()
  1042  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1043  }
  1044  
  1045  func (m *ChangeTypeRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1046  	if m == nil {
  1047  		return 0, nil
  1048  	}
  1049  	i := len(dAtA)
  1050  	_ = i
  1051  	var l int
  1052  	_ = l
  1053  	if m.unknownFields != nil {
  1054  		i -= len(m.unknownFields)
  1055  		copy(dAtA[i:], m.unknownFields)
  1056  	}
  1057  	if m.SemiSync {
  1058  		i--
  1059  		if m.SemiSync {
  1060  			dAtA[i] = 1
  1061  		} else {
  1062  			dAtA[i] = 0
  1063  		}
  1064  		i--
  1065  		dAtA[i] = 0x10
  1066  	}
  1067  	if m.TabletType != 0 {
  1068  		i = encodeVarint(dAtA, i, uint64(m.TabletType))
  1069  		i--
  1070  		dAtA[i] = 0x8
  1071  	}
  1072  	return len(dAtA) - i, nil
  1073  }
  1074  
  1075  func (m *ChangeTypeResponse) 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 *ChangeTypeResponse) MarshalToVT(dAtA []byte) (int, error) {
  1089  	size := m.SizeVT()
  1090  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1091  }
  1092  
  1093  func (m *ChangeTypeResponse) 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  	return len(dAtA) - i, nil
  1106  }
  1107  
  1108  func (m *RefreshStateRequest) MarshalVT() (dAtA []byte, err error) {
  1109  	if m == nil {
  1110  		return nil, nil
  1111  	}
  1112  	size := m.SizeVT()
  1113  	dAtA = make([]byte, size)
  1114  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1115  	if err != nil {
  1116  		return nil, err
  1117  	}
  1118  	return dAtA[:n], nil
  1119  }
  1120  
  1121  func (m *RefreshStateRequest) MarshalToVT(dAtA []byte) (int, error) {
  1122  	size := m.SizeVT()
  1123  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1124  }
  1125  
  1126  func (m *RefreshStateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1127  	if m == nil {
  1128  		return 0, nil
  1129  	}
  1130  	i := len(dAtA)
  1131  	_ = i
  1132  	var l int
  1133  	_ = l
  1134  	if m.unknownFields != nil {
  1135  		i -= len(m.unknownFields)
  1136  		copy(dAtA[i:], m.unknownFields)
  1137  	}
  1138  	return len(dAtA) - i, nil
  1139  }
  1140  
  1141  func (m *RefreshStateResponse) MarshalVT() (dAtA []byte, err error) {
  1142  	if m == nil {
  1143  		return nil, nil
  1144  	}
  1145  	size := m.SizeVT()
  1146  	dAtA = make([]byte, size)
  1147  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1148  	if err != nil {
  1149  		return nil, err
  1150  	}
  1151  	return dAtA[:n], nil
  1152  }
  1153  
  1154  func (m *RefreshStateResponse) MarshalToVT(dAtA []byte) (int, error) {
  1155  	size := m.SizeVT()
  1156  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1157  }
  1158  
  1159  func (m *RefreshStateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1160  	if m == nil {
  1161  		return 0, nil
  1162  	}
  1163  	i := len(dAtA)
  1164  	_ = i
  1165  	var l int
  1166  	_ = l
  1167  	if m.unknownFields != nil {
  1168  		i -= len(m.unknownFields)
  1169  		copy(dAtA[i:], m.unknownFields)
  1170  	}
  1171  	return len(dAtA) - i, nil
  1172  }
  1173  
  1174  func (m *RunHealthCheckRequest) MarshalVT() (dAtA []byte, err error) {
  1175  	if m == nil {
  1176  		return nil, nil
  1177  	}
  1178  	size := m.SizeVT()
  1179  	dAtA = make([]byte, size)
  1180  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1181  	if err != nil {
  1182  		return nil, err
  1183  	}
  1184  	return dAtA[:n], nil
  1185  }
  1186  
  1187  func (m *RunHealthCheckRequest) MarshalToVT(dAtA []byte) (int, error) {
  1188  	size := m.SizeVT()
  1189  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1190  }
  1191  
  1192  func (m *RunHealthCheckRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1193  	if m == nil {
  1194  		return 0, nil
  1195  	}
  1196  	i := len(dAtA)
  1197  	_ = i
  1198  	var l int
  1199  	_ = l
  1200  	if m.unknownFields != nil {
  1201  		i -= len(m.unknownFields)
  1202  		copy(dAtA[i:], m.unknownFields)
  1203  	}
  1204  	return len(dAtA) - i, nil
  1205  }
  1206  
  1207  func (m *RunHealthCheckResponse) MarshalVT() (dAtA []byte, err error) {
  1208  	if m == nil {
  1209  		return nil, nil
  1210  	}
  1211  	size := m.SizeVT()
  1212  	dAtA = make([]byte, size)
  1213  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1214  	if err != nil {
  1215  		return nil, err
  1216  	}
  1217  	return dAtA[:n], nil
  1218  }
  1219  
  1220  func (m *RunHealthCheckResponse) MarshalToVT(dAtA []byte) (int, error) {
  1221  	size := m.SizeVT()
  1222  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1223  }
  1224  
  1225  func (m *RunHealthCheckResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1226  	if m == nil {
  1227  		return 0, nil
  1228  	}
  1229  	i := len(dAtA)
  1230  	_ = i
  1231  	var l int
  1232  	_ = l
  1233  	if m.unknownFields != nil {
  1234  		i -= len(m.unknownFields)
  1235  		copy(dAtA[i:], m.unknownFields)
  1236  	}
  1237  	return len(dAtA) - i, nil
  1238  }
  1239  
  1240  func (m *ReloadSchemaRequest) MarshalVT() (dAtA []byte, err error) {
  1241  	if m == nil {
  1242  		return nil, nil
  1243  	}
  1244  	size := m.SizeVT()
  1245  	dAtA = make([]byte, size)
  1246  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1247  	if err != nil {
  1248  		return nil, err
  1249  	}
  1250  	return dAtA[:n], nil
  1251  }
  1252  
  1253  func (m *ReloadSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  1254  	size := m.SizeVT()
  1255  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1256  }
  1257  
  1258  func (m *ReloadSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1259  	if m == nil {
  1260  		return 0, nil
  1261  	}
  1262  	i := len(dAtA)
  1263  	_ = i
  1264  	var l int
  1265  	_ = l
  1266  	if m.unknownFields != nil {
  1267  		i -= len(m.unknownFields)
  1268  		copy(dAtA[i:], m.unknownFields)
  1269  	}
  1270  	if len(m.WaitPosition) > 0 {
  1271  		i -= len(m.WaitPosition)
  1272  		copy(dAtA[i:], m.WaitPosition)
  1273  		i = encodeVarint(dAtA, i, uint64(len(m.WaitPosition)))
  1274  		i--
  1275  		dAtA[i] = 0xa
  1276  	}
  1277  	return len(dAtA) - i, nil
  1278  }
  1279  
  1280  func (m *ReloadSchemaResponse) MarshalVT() (dAtA []byte, err error) {
  1281  	if m == nil {
  1282  		return nil, nil
  1283  	}
  1284  	size := m.SizeVT()
  1285  	dAtA = make([]byte, size)
  1286  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1287  	if err != nil {
  1288  		return nil, err
  1289  	}
  1290  	return dAtA[:n], nil
  1291  }
  1292  
  1293  func (m *ReloadSchemaResponse) MarshalToVT(dAtA []byte) (int, error) {
  1294  	size := m.SizeVT()
  1295  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1296  }
  1297  
  1298  func (m *ReloadSchemaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1299  	if m == nil {
  1300  		return 0, nil
  1301  	}
  1302  	i := len(dAtA)
  1303  	_ = i
  1304  	var l int
  1305  	_ = l
  1306  	if m.unknownFields != nil {
  1307  		i -= len(m.unknownFields)
  1308  		copy(dAtA[i:], m.unknownFields)
  1309  	}
  1310  	return len(dAtA) - i, nil
  1311  }
  1312  
  1313  func (m *PreflightSchemaRequest) MarshalVT() (dAtA []byte, err error) {
  1314  	if m == nil {
  1315  		return nil, nil
  1316  	}
  1317  	size := m.SizeVT()
  1318  	dAtA = make([]byte, size)
  1319  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1320  	if err != nil {
  1321  		return nil, err
  1322  	}
  1323  	return dAtA[:n], nil
  1324  }
  1325  
  1326  func (m *PreflightSchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  1327  	size := m.SizeVT()
  1328  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1329  }
  1330  
  1331  func (m *PreflightSchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1332  	if m == nil {
  1333  		return 0, nil
  1334  	}
  1335  	i := len(dAtA)
  1336  	_ = i
  1337  	var l int
  1338  	_ = l
  1339  	if m.unknownFields != nil {
  1340  		i -= len(m.unknownFields)
  1341  		copy(dAtA[i:], m.unknownFields)
  1342  	}
  1343  	if len(m.Changes) > 0 {
  1344  		for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- {
  1345  			i -= len(m.Changes[iNdEx])
  1346  			copy(dAtA[i:], m.Changes[iNdEx])
  1347  			i = encodeVarint(dAtA, i, uint64(len(m.Changes[iNdEx])))
  1348  			i--
  1349  			dAtA[i] = 0xa
  1350  		}
  1351  	}
  1352  	return len(dAtA) - i, nil
  1353  }
  1354  
  1355  func (m *PreflightSchemaResponse) MarshalVT() (dAtA []byte, err error) {
  1356  	if m == nil {
  1357  		return nil, nil
  1358  	}
  1359  	size := m.SizeVT()
  1360  	dAtA = make([]byte, size)
  1361  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1362  	if err != nil {
  1363  		return nil, err
  1364  	}
  1365  	return dAtA[:n], nil
  1366  }
  1367  
  1368  func (m *PreflightSchemaResponse) MarshalToVT(dAtA []byte) (int, error) {
  1369  	size := m.SizeVT()
  1370  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1371  }
  1372  
  1373  func (m *PreflightSchemaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1374  	if m == nil {
  1375  		return 0, nil
  1376  	}
  1377  	i := len(dAtA)
  1378  	_ = i
  1379  	var l int
  1380  	_ = l
  1381  	if m.unknownFields != nil {
  1382  		i -= len(m.unknownFields)
  1383  		copy(dAtA[i:], m.unknownFields)
  1384  	}
  1385  	if len(m.ChangeResults) > 0 {
  1386  		for iNdEx := len(m.ChangeResults) - 1; iNdEx >= 0; iNdEx-- {
  1387  			size, err := m.ChangeResults[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
  1388  			if err != nil {
  1389  				return 0, err
  1390  			}
  1391  			i -= size
  1392  			i = encodeVarint(dAtA, i, uint64(size))
  1393  			i--
  1394  			dAtA[i] = 0xa
  1395  		}
  1396  	}
  1397  	return len(dAtA) - i, nil
  1398  }
  1399  
  1400  func (m *ApplySchemaRequest) MarshalVT() (dAtA []byte, err error) {
  1401  	if m == nil {
  1402  		return nil, nil
  1403  	}
  1404  	size := m.SizeVT()
  1405  	dAtA = make([]byte, size)
  1406  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1407  	if err != nil {
  1408  		return nil, err
  1409  	}
  1410  	return dAtA[:n], nil
  1411  }
  1412  
  1413  func (m *ApplySchemaRequest) MarshalToVT(dAtA []byte) (int, error) {
  1414  	size := m.SizeVT()
  1415  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1416  }
  1417  
  1418  func (m *ApplySchemaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1419  	if m == nil {
  1420  		return 0, nil
  1421  	}
  1422  	i := len(dAtA)
  1423  	_ = i
  1424  	var l int
  1425  	_ = l
  1426  	if m.unknownFields != nil {
  1427  		i -= len(m.unknownFields)
  1428  		copy(dAtA[i:], m.unknownFields)
  1429  	}
  1430  	if len(m.SqlMode) > 0 {
  1431  		i -= len(m.SqlMode)
  1432  		copy(dAtA[i:], m.SqlMode)
  1433  		i = encodeVarint(dAtA, i, uint64(len(m.SqlMode)))
  1434  		i--
  1435  		dAtA[i] = 0x32
  1436  	}
  1437  	if m.AfterSchema != nil {
  1438  		size, err := m.AfterSchema.MarshalToSizedBufferVT(dAtA[:i])
  1439  		if err != nil {
  1440  			return 0, err
  1441  		}
  1442  		i -= size
  1443  		i = encodeVarint(dAtA, i, uint64(size))
  1444  		i--
  1445  		dAtA[i] = 0x2a
  1446  	}
  1447  	if m.BeforeSchema != nil {
  1448  		size, err := m.BeforeSchema.MarshalToSizedBufferVT(dAtA[:i])
  1449  		if err != nil {
  1450  			return 0, err
  1451  		}
  1452  		i -= size
  1453  		i = encodeVarint(dAtA, i, uint64(size))
  1454  		i--
  1455  		dAtA[i] = 0x22
  1456  	}
  1457  	if m.AllowReplication {
  1458  		i--
  1459  		if m.AllowReplication {
  1460  			dAtA[i] = 1
  1461  		} else {
  1462  			dAtA[i] = 0
  1463  		}
  1464  		i--
  1465  		dAtA[i] = 0x18
  1466  	}
  1467  	if m.Force {
  1468  		i--
  1469  		if m.Force {
  1470  			dAtA[i] = 1
  1471  		} else {
  1472  			dAtA[i] = 0
  1473  		}
  1474  		i--
  1475  		dAtA[i] = 0x10
  1476  	}
  1477  	if len(m.Sql) > 0 {
  1478  		i -= len(m.Sql)
  1479  		copy(dAtA[i:], m.Sql)
  1480  		i = encodeVarint(dAtA, i, uint64(len(m.Sql)))
  1481  		i--
  1482  		dAtA[i] = 0xa
  1483  	}
  1484  	return len(dAtA) - i, nil
  1485  }
  1486  
  1487  func (m *ApplySchemaResponse) MarshalVT() (dAtA []byte, err error) {
  1488  	if m == nil {
  1489  		return nil, nil
  1490  	}
  1491  	size := m.SizeVT()
  1492  	dAtA = make([]byte, size)
  1493  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1494  	if err != nil {
  1495  		return nil, err
  1496  	}
  1497  	return dAtA[:n], nil
  1498  }
  1499  
  1500  func (m *ApplySchemaResponse) MarshalToVT(dAtA []byte) (int, error) {
  1501  	size := m.SizeVT()
  1502  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1503  }
  1504  
  1505  func (m *ApplySchemaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1506  	if m == nil {
  1507  		return 0, nil
  1508  	}
  1509  	i := len(dAtA)
  1510  	_ = i
  1511  	var l int
  1512  	_ = l
  1513  	if m.unknownFields != nil {
  1514  		i -= len(m.unknownFields)
  1515  		copy(dAtA[i:], m.unknownFields)
  1516  	}
  1517  	if m.AfterSchema != nil {
  1518  		size, err := m.AfterSchema.MarshalToSizedBufferVT(dAtA[:i])
  1519  		if err != nil {
  1520  			return 0, err
  1521  		}
  1522  		i -= size
  1523  		i = encodeVarint(dAtA, i, uint64(size))
  1524  		i--
  1525  		dAtA[i] = 0x12
  1526  	}
  1527  	if m.BeforeSchema != nil {
  1528  		size, err := m.BeforeSchema.MarshalToSizedBufferVT(dAtA[:i])
  1529  		if err != nil {
  1530  			return 0, err
  1531  		}
  1532  		i -= size
  1533  		i = encodeVarint(dAtA, i, uint64(size))
  1534  		i--
  1535  		dAtA[i] = 0xa
  1536  	}
  1537  	return len(dAtA) - i, nil
  1538  }
  1539  
  1540  func (m *LockTablesRequest) MarshalVT() (dAtA []byte, err error) {
  1541  	if m == nil {
  1542  		return nil, nil
  1543  	}
  1544  	size := m.SizeVT()
  1545  	dAtA = make([]byte, size)
  1546  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1547  	if err != nil {
  1548  		return nil, err
  1549  	}
  1550  	return dAtA[:n], nil
  1551  }
  1552  
  1553  func (m *LockTablesRequest) MarshalToVT(dAtA []byte) (int, error) {
  1554  	size := m.SizeVT()
  1555  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1556  }
  1557  
  1558  func (m *LockTablesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1559  	if m == nil {
  1560  		return 0, nil
  1561  	}
  1562  	i := len(dAtA)
  1563  	_ = i
  1564  	var l int
  1565  	_ = l
  1566  	if m.unknownFields != nil {
  1567  		i -= len(m.unknownFields)
  1568  		copy(dAtA[i:], m.unknownFields)
  1569  	}
  1570  	return len(dAtA) - i, nil
  1571  }
  1572  
  1573  func (m *LockTablesResponse) MarshalVT() (dAtA []byte, err error) {
  1574  	if m == nil {
  1575  		return nil, nil
  1576  	}
  1577  	size := m.SizeVT()
  1578  	dAtA = make([]byte, size)
  1579  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1580  	if err != nil {
  1581  		return nil, err
  1582  	}
  1583  	return dAtA[:n], nil
  1584  }
  1585  
  1586  func (m *LockTablesResponse) MarshalToVT(dAtA []byte) (int, error) {
  1587  	size := m.SizeVT()
  1588  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1589  }
  1590  
  1591  func (m *LockTablesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1592  	if m == nil {
  1593  		return 0, nil
  1594  	}
  1595  	i := len(dAtA)
  1596  	_ = i
  1597  	var l int
  1598  	_ = l
  1599  	if m.unknownFields != nil {
  1600  		i -= len(m.unknownFields)
  1601  		copy(dAtA[i:], m.unknownFields)
  1602  	}
  1603  	return len(dAtA) - i, nil
  1604  }
  1605  
  1606  func (m *UnlockTablesRequest) MarshalVT() (dAtA []byte, err error) {
  1607  	if m == nil {
  1608  		return nil, nil
  1609  	}
  1610  	size := m.SizeVT()
  1611  	dAtA = make([]byte, size)
  1612  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1613  	if err != nil {
  1614  		return nil, err
  1615  	}
  1616  	return dAtA[:n], nil
  1617  }
  1618  
  1619  func (m *UnlockTablesRequest) MarshalToVT(dAtA []byte) (int, error) {
  1620  	size := m.SizeVT()
  1621  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1622  }
  1623  
  1624  func (m *UnlockTablesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1625  	if m == nil {
  1626  		return 0, nil
  1627  	}
  1628  	i := len(dAtA)
  1629  	_ = i
  1630  	var l int
  1631  	_ = l
  1632  	if m.unknownFields != nil {
  1633  		i -= len(m.unknownFields)
  1634  		copy(dAtA[i:], m.unknownFields)
  1635  	}
  1636  	return len(dAtA) - i, nil
  1637  }
  1638  
  1639  func (m *UnlockTablesResponse) MarshalVT() (dAtA []byte, err error) {
  1640  	if m == nil {
  1641  		return nil, nil
  1642  	}
  1643  	size := m.SizeVT()
  1644  	dAtA = make([]byte, size)
  1645  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1646  	if err != nil {
  1647  		return nil, err
  1648  	}
  1649  	return dAtA[:n], nil
  1650  }
  1651  
  1652  func (m *UnlockTablesResponse) MarshalToVT(dAtA []byte) (int, error) {
  1653  	size := m.SizeVT()
  1654  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1655  }
  1656  
  1657  func (m *UnlockTablesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1658  	if m == nil {
  1659  		return 0, nil
  1660  	}
  1661  	i := len(dAtA)
  1662  	_ = i
  1663  	var l int
  1664  	_ = l
  1665  	if m.unknownFields != nil {
  1666  		i -= len(m.unknownFields)
  1667  		copy(dAtA[i:], m.unknownFields)
  1668  	}
  1669  	return len(dAtA) - i, nil
  1670  }
  1671  
  1672  func (m *ExecuteQueryRequest) MarshalVT() (dAtA []byte, err error) {
  1673  	if m == nil {
  1674  		return nil, nil
  1675  	}
  1676  	size := m.SizeVT()
  1677  	dAtA = make([]byte, size)
  1678  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1679  	if err != nil {
  1680  		return nil, err
  1681  	}
  1682  	return dAtA[:n], nil
  1683  }
  1684  
  1685  func (m *ExecuteQueryRequest) MarshalToVT(dAtA []byte) (int, error) {
  1686  	size := m.SizeVT()
  1687  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1688  }
  1689  
  1690  func (m *ExecuteQueryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1691  	if m == nil {
  1692  		return 0, nil
  1693  	}
  1694  	i := len(dAtA)
  1695  	_ = i
  1696  	var l int
  1697  	_ = l
  1698  	if m.unknownFields != nil {
  1699  		i -= len(m.unknownFields)
  1700  		copy(dAtA[i:], m.unknownFields)
  1701  	}
  1702  	if m.CallerId != nil {
  1703  		size, err := m.CallerId.MarshalToSizedBufferVT(dAtA[:i])
  1704  		if err != nil {
  1705  			return 0, err
  1706  		}
  1707  		i -= size
  1708  		i = encodeVarint(dAtA, i, uint64(size))
  1709  		i--
  1710  		dAtA[i] = 0x22
  1711  	}
  1712  	if m.MaxRows != 0 {
  1713  		i = encodeVarint(dAtA, i, uint64(m.MaxRows))
  1714  		i--
  1715  		dAtA[i] = 0x18
  1716  	}
  1717  	if len(m.DbName) > 0 {
  1718  		i -= len(m.DbName)
  1719  		copy(dAtA[i:], m.DbName)
  1720  		i = encodeVarint(dAtA, i, uint64(len(m.DbName)))
  1721  		i--
  1722  		dAtA[i] = 0x12
  1723  	}
  1724  	if len(m.Query) > 0 {
  1725  		i -= len(m.Query)
  1726  		copy(dAtA[i:], m.Query)
  1727  		i = encodeVarint(dAtA, i, uint64(len(m.Query)))
  1728  		i--
  1729  		dAtA[i] = 0xa
  1730  	}
  1731  	return len(dAtA) - i, nil
  1732  }
  1733  
  1734  func (m *ExecuteQueryResponse) MarshalVT() (dAtA []byte, err error) {
  1735  	if m == nil {
  1736  		return nil, nil
  1737  	}
  1738  	size := m.SizeVT()
  1739  	dAtA = make([]byte, size)
  1740  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1741  	if err != nil {
  1742  		return nil, err
  1743  	}
  1744  	return dAtA[:n], nil
  1745  }
  1746  
  1747  func (m *ExecuteQueryResponse) MarshalToVT(dAtA []byte) (int, error) {
  1748  	size := m.SizeVT()
  1749  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1750  }
  1751  
  1752  func (m *ExecuteQueryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1753  	if m == nil {
  1754  		return 0, nil
  1755  	}
  1756  	i := len(dAtA)
  1757  	_ = i
  1758  	var l int
  1759  	_ = l
  1760  	if m.unknownFields != nil {
  1761  		i -= len(m.unknownFields)
  1762  		copy(dAtA[i:], m.unknownFields)
  1763  	}
  1764  	if m.Result != nil {
  1765  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  1766  		if err != nil {
  1767  			return 0, err
  1768  		}
  1769  		i -= size
  1770  		i = encodeVarint(dAtA, i, uint64(size))
  1771  		i--
  1772  		dAtA[i] = 0xa
  1773  	}
  1774  	return len(dAtA) - i, nil
  1775  }
  1776  
  1777  func (m *ExecuteFetchAsDbaRequest) MarshalVT() (dAtA []byte, err error) {
  1778  	if m == nil {
  1779  		return nil, nil
  1780  	}
  1781  	size := m.SizeVT()
  1782  	dAtA = make([]byte, size)
  1783  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1784  	if err != nil {
  1785  		return nil, err
  1786  	}
  1787  	return dAtA[:n], nil
  1788  }
  1789  
  1790  func (m *ExecuteFetchAsDbaRequest) MarshalToVT(dAtA []byte) (int, error) {
  1791  	size := m.SizeVT()
  1792  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1793  }
  1794  
  1795  func (m *ExecuteFetchAsDbaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1796  	if m == nil {
  1797  		return 0, nil
  1798  	}
  1799  	i := len(dAtA)
  1800  	_ = i
  1801  	var l int
  1802  	_ = l
  1803  	if m.unknownFields != nil {
  1804  		i -= len(m.unknownFields)
  1805  		copy(dAtA[i:], m.unknownFields)
  1806  	}
  1807  	if m.ReloadSchema {
  1808  		i--
  1809  		if m.ReloadSchema {
  1810  			dAtA[i] = 1
  1811  		} else {
  1812  			dAtA[i] = 0
  1813  		}
  1814  		i--
  1815  		dAtA[i] = 0x28
  1816  	}
  1817  	if m.DisableBinlogs {
  1818  		i--
  1819  		if m.DisableBinlogs {
  1820  			dAtA[i] = 1
  1821  		} else {
  1822  			dAtA[i] = 0
  1823  		}
  1824  		i--
  1825  		dAtA[i] = 0x20
  1826  	}
  1827  	if m.MaxRows != 0 {
  1828  		i = encodeVarint(dAtA, i, uint64(m.MaxRows))
  1829  		i--
  1830  		dAtA[i] = 0x18
  1831  	}
  1832  	if len(m.DbName) > 0 {
  1833  		i -= len(m.DbName)
  1834  		copy(dAtA[i:], m.DbName)
  1835  		i = encodeVarint(dAtA, i, uint64(len(m.DbName)))
  1836  		i--
  1837  		dAtA[i] = 0x12
  1838  	}
  1839  	if len(m.Query) > 0 {
  1840  		i -= len(m.Query)
  1841  		copy(dAtA[i:], m.Query)
  1842  		i = encodeVarint(dAtA, i, uint64(len(m.Query)))
  1843  		i--
  1844  		dAtA[i] = 0xa
  1845  	}
  1846  	return len(dAtA) - i, nil
  1847  }
  1848  
  1849  func (m *ExecuteFetchAsDbaResponse) MarshalVT() (dAtA []byte, err error) {
  1850  	if m == nil {
  1851  		return nil, nil
  1852  	}
  1853  	size := m.SizeVT()
  1854  	dAtA = make([]byte, size)
  1855  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1856  	if err != nil {
  1857  		return nil, err
  1858  	}
  1859  	return dAtA[:n], nil
  1860  }
  1861  
  1862  func (m *ExecuteFetchAsDbaResponse) MarshalToVT(dAtA []byte) (int, error) {
  1863  	size := m.SizeVT()
  1864  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1865  }
  1866  
  1867  func (m *ExecuteFetchAsDbaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1868  	if m == nil {
  1869  		return 0, nil
  1870  	}
  1871  	i := len(dAtA)
  1872  	_ = i
  1873  	var l int
  1874  	_ = l
  1875  	if m.unknownFields != nil {
  1876  		i -= len(m.unknownFields)
  1877  		copy(dAtA[i:], m.unknownFields)
  1878  	}
  1879  	if m.Result != nil {
  1880  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  1881  		if err != nil {
  1882  			return 0, err
  1883  		}
  1884  		i -= size
  1885  		i = encodeVarint(dAtA, i, uint64(size))
  1886  		i--
  1887  		dAtA[i] = 0xa
  1888  	}
  1889  	return len(dAtA) - i, nil
  1890  }
  1891  
  1892  func (m *ExecuteFetchAsAllPrivsRequest) MarshalVT() (dAtA []byte, err error) {
  1893  	if m == nil {
  1894  		return nil, nil
  1895  	}
  1896  	size := m.SizeVT()
  1897  	dAtA = make([]byte, size)
  1898  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1899  	if err != nil {
  1900  		return nil, err
  1901  	}
  1902  	return dAtA[:n], nil
  1903  }
  1904  
  1905  func (m *ExecuteFetchAsAllPrivsRequest) MarshalToVT(dAtA []byte) (int, error) {
  1906  	size := m.SizeVT()
  1907  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1908  }
  1909  
  1910  func (m *ExecuteFetchAsAllPrivsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1911  	if m == nil {
  1912  		return 0, nil
  1913  	}
  1914  	i := len(dAtA)
  1915  	_ = i
  1916  	var l int
  1917  	_ = l
  1918  	if m.unknownFields != nil {
  1919  		i -= len(m.unknownFields)
  1920  		copy(dAtA[i:], m.unknownFields)
  1921  	}
  1922  	if m.ReloadSchema {
  1923  		i--
  1924  		if m.ReloadSchema {
  1925  			dAtA[i] = 1
  1926  		} else {
  1927  			dAtA[i] = 0
  1928  		}
  1929  		i--
  1930  		dAtA[i] = 0x20
  1931  	}
  1932  	if m.MaxRows != 0 {
  1933  		i = encodeVarint(dAtA, i, uint64(m.MaxRows))
  1934  		i--
  1935  		dAtA[i] = 0x18
  1936  	}
  1937  	if len(m.DbName) > 0 {
  1938  		i -= len(m.DbName)
  1939  		copy(dAtA[i:], m.DbName)
  1940  		i = encodeVarint(dAtA, i, uint64(len(m.DbName)))
  1941  		i--
  1942  		dAtA[i] = 0x12
  1943  	}
  1944  	if len(m.Query) > 0 {
  1945  		i -= len(m.Query)
  1946  		copy(dAtA[i:], m.Query)
  1947  		i = encodeVarint(dAtA, i, uint64(len(m.Query)))
  1948  		i--
  1949  		dAtA[i] = 0xa
  1950  	}
  1951  	return len(dAtA) - i, nil
  1952  }
  1953  
  1954  func (m *ExecuteFetchAsAllPrivsResponse) MarshalVT() (dAtA []byte, err error) {
  1955  	if m == nil {
  1956  		return nil, nil
  1957  	}
  1958  	size := m.SizeVT()
  1959  	dAtA = make([]byte, size)
  1960  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  1961  	if err != nil {
  1962  		return nil, err
  1963  	}
  1964  	return dAtA[:n], nil
  1965  }
  1966  
  1967  func (m *ExecuteFetchAsAllPrivsResponse) MarshalToVT(dAtA []byte) (int, error) {
  1968  	size := m.SizeVT()
  1969  	return m.MarshalToSizedBufferVT(dAtA[:size])
  1970  }
  1971  
  1972  func (m *ExecuteFetchAsAllPrivsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  1973  	if m == nil {
  1974  		return 0, nil
  1975  	}
  1976  	i := len(dAtA)
  1977  	_ = i
  1978  	var l int
  1979  	_ = l
  1980  	if m.unknownFields != nil {
  1981  		i -= len(m.unknownFields)
  1982  		copy(dAtA[i:], m.unknownFields)
  1983  	}
  1984  	if m.Result != nil {
  1985  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  1986  		if err != nil {
  1987  			return 0, err
  1988  		}
  1989  		i -= size
  1990  		i = encodeVarint(dAtA, i, uint64(size))
  1991  		i--
  1992  		dAtA[i] = 0xa
  1993  	}
  1994  	return len(dAtA) - i, nil
  1995  }
  1996  
  1997  func (m *ExecuteFetchAsAppRequest) MarshalVT() (dAtA []byte, err error) {
  1998  	if m == nil {
  1999  		return nil, nil
  2000  	}
  2001  	size := m.SizeVT()
  2002  	dAtA = make([]byte, size)
  2003  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2004  	if err != nil {
  2005  		return nil, err
  2006  	}
  2007  	return dAtA[:n], nil
  2008  }
  2009  
  2010  func (m *ExecuteFetchAsAppRequest) MarshalToVT(dAtA []byte) (int, error) {
  2011  	size := m.SizeVT()
  2012  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2013  }
  2014  
  2015  func (m *ExecuteFetchAsAppRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2016  	if m == nil {
  2017  		return 0, nil
  2018  	}
  2019  	i := len(dAtA)
  2020  	_ = i
  2021  	var l int
  2022  	_ = l
  2023  	if m.unknownFields != nil {
  2024  		i -= len(m.unknownFields)
  2025  		copy(dAtA[i:], m.unknownFields)
  2026  	}
  2027  	if m.MaxRows != 0 {
  2028  		i = encodeVarint(dAtA, i, uint64(m.MaxRows))
  2029  		i--
  2030  		dAtA[i] = 0x10
  2031  	}
  2032  	if len(m.Query) > 0 {
  2033  		i -= len(m.Query)
  2034  		copy(dAtA[i:], m.Query)
  2035  		i = encodeVarint(dAtA, i, uint64(len(m.Query)))
  2036  		i--
  2037  		dAtA[i] = 0xa
  2038  	}
  2039  	return len(dAtA) - i, nil
  2040  }
  2041  
  2042  func (m *ExecuteFetchAsAppResponse) MarshalVT() (dAtA []byte, err error) {
  2043  	if m == nil {
  2044  		return nil, nil
  2045  	}
  2046  	size := m.SizeVT()
  2047  	dAtA = make([]byte, size)
  2048  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2049  	if err != nil {
  2050  		return nil, err
  2051  	}
  2052  	return dAtA[:n], nil
  2053  }
  2054  
  2055  func (m *ExecuteFetchAsAppResponse) MarshalToVT(dAtA []byte) (int, error) {
  2056  	size := m.SizeVT()
  2057  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2058  }
  2059  
  2060  func (m *ExecuteFetchAsAppResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2061  	if m == nil {
  2062  		return 0, nil
  2063  	}
  2064  	i := len(dAtA)
  2065  	_ = i
  2066  	var l int
  2067  	_ = l
  2068  	if m.unknownFields != nil {
  2069  		i -= len(m.unknownFields)
  2070  		copy(dAtA[i:], m.unknownFields)
  2071  	}
  2072  	if m.Result != nil {
  2073  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  2074  		if err != nil {
  2075  			return 0, err
  2076  		}
  2077  		i -= size
  2078  		i = encodeVarint(dAtA, i, uint64(size))
  2079  		i--
  2080  		dAtA[i] = 0xa
  2081  	}
  2082  	return len(dAtA) - i, nil
  2083  }
  2084  
  2085  func (m *ReplicationStatusRequest) MarshalVT() (dAtA []byte, err error) {
  2086  	if m == nil {
  2087  		return nil, nil
  2088  	}
  2089  	size := m.SizeVT()
  2090  	dAtA = make([]byte, size)
  2091  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2092  	if err != nil {
  2093  		return nil, err
  2094  	}
  2095  	return dAtA[:n], nil
  2096  }
  2097  
  2098  func (m *ReplicationStatusRequest) MarshalToVT(dAtA []byte) (int, error) {
  2099  	size := m.SizeVT()
  2100  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2101  }
  2102  
  2103  func (m *ReplicationStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2104  	if m == nil {
  2105  		return 0, nil
  2106  	}
  2107  	i := len(dAtA)
  2108  	_ = i
  2109  	var l int
  2110  	_ = l
  2111  	if m.unknownFields != nil {
  2112  		i -= len(m.unknownFields)
  2113  		copy(dAtA[i:], m.unknownFields)
  2114  	}
  2115  	return len(dAtA) - i, nil
  2116  }
  2117  
  2118  func (m *ReplicationStatusResponse) MarshalVT() (dAtA []byte, err error) {
  2119  	if m == nil {
  2120  		return nil, nil
  2121  	}
  2122  	size := m.SizeVT()
  2123  	dAtA = make([]byte, size)
  2124  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2125  	if err != nil {
  2126  		return nil, err
  2127  	}
  2128  	return dAtA[:n], nil
  2129  }
  2130  
  2131  func (m *ReplicationStatusResponse) MarshalToVT(dAtA []byte) (int, error) {
  2132  	size := m.SizeVT()
  2133  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2134  }
  2135  
  2136  func (m *ReplicationStatusResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2137  	if m == nil {
  2138  		return 0, nil
  2139  	}
  2140  	i := len(dAtA)
  2141  	_ = i
  2142  	var l int
  2143  	_ = l
  2144  	if m.unknownFields != nil {
  2145  		i -= len(m.unknownFields)
  2146  		copy(dAtA[i:], m.unknownFields)
  2147  	}
  2148  	if m.Status != nil {
  2149  		size, err := m.Status.MarshalToSizedBufferVT(dAtA[:i])
  2150  		if err != nil {
  2151  			return 0, err
  2152  		}
  2153  		i -= size
  2154  		i = encodeVarint(dAtA, i, uint64(size))
  2155  		i--
  2156  		dAtA[i] = 0xa
  2157  	}
  2158  	return len(dAtA) - i, nil
  2159  }
  2160  
  2161  func (m *PrimaryStatusRequest) MarshalVT() (dAtA []byte, err error) {
  2162  	if m == nil {
  2163  		return nil, nil
  2164  	}
  2165  	size := m.SizeVT()
  2166  	dAtA = make([]byte, size)
  2167  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2168  	if err != nil {
  2169  		return nil, err
  2170  	}
  2171  	return dAtA[:n], nil
  2172  }
  2173  
  2174  func (m *PrimaryStatusRequest) MarshalToVT(dAtA []byte) (int, error) {
  2175  	size := m.SizeVT()
  2176  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2177  }
  2178  
  2179  func (m *PrimaryStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2180  	if m == nil {
  2181  		return 0, nil
  2182  	}
  2183  	i := len(dAtA)
  2184  	_ = i
  2185  	var l int
  2186  	_ = l
  2187  	if m.unknownFields != nil {
  2188  		i -= len(m.unknownFields)
  2189  		copy(dAtA[i:], m.unknownFields)
  2190  	}
  2191  	return len(dAtA) - i, nil
  2192  }
  2193  
  2194  func (m *PrimaryStatusResponse) MarshalVT() (dAtA []byte, err error) {
  2195  	if m == nil {
  2196  		return nil, nil
  2197  	}
  2198  	size := m.SizeVT()
  2199  	dAtA = make([]byte, size)
  2200  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2201  	if err != nil {
  2202  		return nil, err
  2203  	}
  2204  	return dAtA[:n], nil
  2205  }
  2206  
  2207  func (m *PrimaryStatusResponse) MarshalToVT(dAtA []byte) (int, error) {
  2208  	size := m.SizeVT()
  2209  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2210  }
  2211  
  2212  func (m *PrimaryStatusResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2213  	if m == nil {
  2214  		return 0, nil
  2215  	}
  2216  	i := len(dAtA)
  2217  	_ = i
  2218  	var l int
  2219  	_ = l
  2220  	if m.unknownFields != nil {
  2221  		i -= len(m.unknownFields)
  2222  		copy(dAtA[i:], m.unknownFields)
  2223  	}
  2224  	if m.Status != nil {
  2225  		size, err := m.Status.MarshalToSizedBufferVT(dAtA[:i])
  2226  		if err != nil {
  2227  			return 0, err
  2228  		}
  2229  		i -= size
  2230  		i = encodeVarint(dAtA, i, uint64(size))
  2231  		i--
  2232  		dAtA[i] = 0xa
  2233  	}
  2234  	return len(dAtA) - i, nil
  2235  }
  2236  
  2237  func (m *PrimaryPositionRequest) MarshalVT() (dAtA []byte, err error) {
  2238  	if m == nil {
  2239  		return nil, nil
  2240  	}
  2241  	size := m.SizeVT()
  2242  	dAtA = make([]byte, size)
  2243  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2244  	if err != nil {
  2245  		return nil, err
  2246  	}
  2247  	return dAtA[:n], nil
  2248  }
  2249  
  2250  func (m *PrimaryPositionRequest) MarshalToVT(dAtA []byte) (int, error) {
  2251  	size := m.SizeVT()
  2252  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2253  }
  2254  
  2255  func (m *PrimaryPositionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2256  	if m == nil {
  2257  		return 0, nil
  2258  	}
  2259  	i := len(dAtA)
  2260  	_ = i
  2261  	var l int
  2262  	_ = l
  2263  	if m.unknownFields != nil {
  2264  		i -= len(m.unknownFields)
  2265  		copy(dAtA[i:], m.unknownFields)
  2266  	}
  2267  	return len(dAtA) - i, nil
  2268  }
  2269  
  2270  func (m *PrimaryPositionResponse) MarshalVT() (dAtA []byte, err error) {
  2271  	if m == nil {
  2272  		return nil, nil
  2273  	}
  2274  	size := m.SizeVT()
  2275  	dAtA = make([]byte, size)
  2276  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2277  	if err != nil {
  2278  		return nil, err
  2279  	}
  2280  	return dAtA[:n], nil
  2281  }
  2282  
  2283  func (m *PrimaryPositionResponse) MarshalToVT(dAtA []byte) (int, error) {
  2284  	size := m.SizeVT()
  2285  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2286  }
  2287  
  2288  func (m *PrimaryPositionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2289  	if m == nil {
  2290  		return 0, nil
  2291  	}
  2292  	i := len(dAtA)
  2293  	_ = i
  2294  	var l int
  2295  	_ = l
  2296  	if m.unknownFields != nil {
  2297  		i -= len(m.unknownFields)
  2298  		copy(dAtA[i:], m.unknownFields)
  2299  	}
  2300  	if len(m.Position) > 0 {
  2301  		i -= len(m.Position)
  2302  		copy(dAtA[i:], m.Position)
  2303  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  2304  		i--
  2305  		dAtA[i] = 0xa
  2306  	}
  2307  	return len(dAtA) - i, nil
  2308  }
  2309  
  2310  func (m *WaitForPositionRequest) MarshalVT() (dAtA []byte, err error) {
  2311  	if m == nil {
  2312  		return nil, nil
  2313  	}
  2314  	size := m.SizeVT()
  2315  	dAtA = make([]byte, size)
  2316  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2317  	if err != nil {
  2318  		return nil, err
  2319  	}
  2320  	return dAtA[:n], nil
  2321  }
  2322  
  2323  func (m *WaitForPositionRequest) MarshalToVT(dAtA []byte) (int, error) {
  2324  	size := m.SizeVT()
  2325  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2326  }
  2327  
  2328  func (m *WaitForPositionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2329  	if m == nil {
  2330  		return 0, nil
  2331  	}
  2332  	i := len(dAtA)
  2333  	_ = i
  2334  	var l int
  2335  	_ = l
  2336  	if m.unknownFields != nil {
  2337  		i -= len(m.unknownFields)
  2338  		copy(dAtA[i:], m.unknownFields)
  2339  	}
  2340  	if len(m.Position) > 0 {
  2341  		i -= len(m.Position)
  2342  		copy(dAtA[i:], m.Position)
  2343  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  2344  		i--
  2345  		dAtA[i] = 0xa
  2346  	}
  2347  	return len(dAtA) - i, nil
  2348  }
  2349  
  2350  func (m *WaitForPositionResponse) MarshalVT() (dAtA []byte, err error) {
  2351  	if m == nil {
  2352  		return nil, nil
  2353  	}
  2354  	size := m.SizeVT()
  2355  	dAtA = make([]byte, size)
  2356  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2357  	if err != nil {
  2358  		return nil, err
  2359  	}
  2360  	return dAtA[:n], nil
  2361  }
  2362  
  2363  func (m *WaitForPositionResponse) MarshalToVT(dAtA []byte) (int, error) {
  2364  	size := m.SizeVT()
  2365  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2366  }
  2367  
  2368  func (m *WaitForPositionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2369  	if m == nil {
  2370  		return 0, nil
  2371  	}
  2372  	i := len(dAtA)
  2373  	_ = i
  2374  	var l int
  2375  	_ = l
  2376  	if m.unknownFields != nil {
  2377  		i -= len(m.unknownFields)
  2378  		copy(dAtA[i:], m.unknownFields)
  2379  	}
  2380  	return len(dAtA) - i, nil
  2381  }
  2382  
  2383  func (m *StopReplicationRequest) MarshalVT() (dAtA []byte, err error) {
  2384  	if m == nil {
  2385  		return nil, nil
  2386  	}
  2387  	size := m.SizeVT()
  2388  	dAtA = make([]byte, size)
  2389  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2390  	if err != nil {
  2391  		return nil, err
  2392  	}
  2393  	return dAtA[:n], nil
  2394  }
  2395  
  2396  func (m *StopReplicationRequest) MarshalToVT(dAtA []byte) (int, error) {
  2397  	size := m.SizeVT()
  2398  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2399  }
  2400  
  2401  func (m *StopReplicationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2402  	if m == nil {
  2403  		return 0, nil
  2404  	}
  2405  	i := len(dAtA)
  2406  	_ = i
  2407  	var l int
  2408  	_ = l
  2409  	if m.unknownFields != nil {
  2410  		i -= len(m.unknownFields)
  2411  		copy(dAtA[i:], m.unknownFields)
  2412  	}
  2413  	return len(dAtA) - i, nil
  2414  }
  2415  
  2416  func (m *StopReplicationResponse) MarshalVT() (dAtA []byte, err error) {
  2417  	if m == nil {
  2418  		return nil, nil
  2419  	}
  2420  	size := m.SizeVT()
  2421  	dAtA = make([]byte, size)
  2422  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2423  	if err != nil {
  2424  		return nil, err
  2425  	}
  2426  	return dAtA[:n], nil
  2427  }
  2428  
  2429  func (m *StopReplicationResponse) MarshalToVT(dAtA []byte) (int, error) {
  2430  	size := m.SizeVT()
  2431  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2432  }
  2433  
  2434  func (m *StopReplicationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2435  	if m == nil {
  2436  		return 0, nil
  2437  	}
  2438  	i := len(dAtA)
  2439  	_ = i
  2440  	var l int
  2441  	_ = l
  2442  	if m.unknownFields != nil {
  2443  		i -= len(m.unknownFields)
  2444  		copy(dAtA[i:], m.unknownFields)
  2445  	}
  2446  	return len(dAtA) - i, nil
  2447  }
  2448  
  2449  func (m *StopReplicationMinimumRequest) MarshalVT() (dAtA []byte, err error) {
  2450  	if m == nil {
  2451  		return nil, nil
  2452  	}
  2453  	size := m.SizeVT()
  2454  	dAtA = make([]byte, size)
  2455  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2456  	if err != nil {
  2457  		return nil, err
  2458  	}
  2459  	return dAtA[:n], nil
  2460  }
  2461  
  2462  func (m *StopReplicationMinimumRequest) MarshalToVT(dAtA []byte) (int, error) {
  2463  	size := m.SizeVT()
  2464  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2465  }
  2466  
  2467  func (m *StopReplicationMinimumRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2468  	if m == nil {
  2469  		return 0, nil
  2470  	}
  2471  	i := len(dAtA)
  2472  	_ = i
  2473  	var l int
  2474  	_ = l
  2475  	if m.unknownFields != nil {
  2476  		i -= len(m.unknownFields)
  2477  		copy(dAtA[i:], m.unknownFields)
  2478  	}
  2479  	if m.WaitTimeout != 0 {
  2480  		i = encodeVarint(dAtA, i, uint64(m.WaitTimeout))
  2481  		i--
  2482  		dAtA[i] = 0x10
  2483  	}
  2484  	if len(m.Position) > 0 {
  2485  		i -= len(m.Position)
  2486  		copy(dAtA[i:], m.Position)
  2487  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  2488  		i--
  2489  		dAtA[i] = 0xa
  2490  	}
  2491  	return len(dAtA) - i, nil
  2492  }
  2493  
  2494  func (m *StopReplicationMinimumResponse) MarshalVT() (dAtA []byte, err error) {
  2495  	if m == nil {
  2496  		return nil, nil
  2497  	}
  2498  	size := m.SizeVT()
  2499  	dAtA = make([]byte, size)
  2500  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2501  	if err != nil {
  2502  		return nil, err
  2503  	}
  2504  	return dAtA[:n], nil
  2505  }
  2506  
  2507  func (m *StopReplicationMinimumResponse) MarshalToVT(dAtA []byte) (int, error) {
  2508  	size := m.SizeVT()
  2509  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2510  }
  2511  
  2512  func (m *StopReplicationMinimumResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2513  	if m == nil {
  2514  		return 0, nil
  2515  	}
  2516  	i := len(dAtA)
  2517  	_ = i
  2518  	var l int
  2519  	_ = l
  2520  	if m.unknownFields != nil {
  2521  		i -= len(m.unknownFields)
  2522  		copy(dAtA[i:], m.unknownFields)
  2523  	}
  2524  	if len(m.Position) > 0 {
  2525  		i -= len(m.Position)
  2526  		copy(dAtA[i:], m.Position)
  2527  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  2528  		i--
  2529  		dAtA[i] = 0xa
  2530  	}
  2531  	return len(dAtA) - i, nil
  2532  }
  2533  
  2534  func (m *StartReplicationRequest) MarshalVT() (dAtA []byte, err error) {
  2535  	if m == nil {
  2536  		return nil, nil
  2537  	}
  2538  	size := m.SizeVT()
  2539  	dAtA = make([]byte, size)
  2540  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2541  	if err != nil {
  2542  		return nil, err
  2543  	}
  2544  	return dAtA[:n], nil
  2545  }
  2546  
  2547  func (m *StartReplicationRequest) MarshalToVT(dAtA []byte) (int, error) {
  2548  	size := m.SizeVT()
  2549  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2550  }
  2551  
  2552  func (m *StartReplicationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2553  	if m == nil {
  2554  		return 0, nil
  2555  	}
  2556  	i := len(dAtA)
  2557  	_ = i
  2558  	var l int
  2559  	_ = l
  2560  	if m.unknownFields != nil {
  2561  		i -= len(m.unknownFields)
  2562  		copy(dAtA[i:], m.unknownFields)
  2563  	}
  2564  	if m.SemiSync {
  2565  		i--
  2566  		if m.SemiSync {
  2567  			dAtA[i] = 1
  2568  		} else {
  2569  			dAtA[i] = 0
  2570  		}
  2571  		i--
  2572  		dAtA[i] = 0x8
  2573  	}
  2574  	return len(dAtA) - i, nil
  2575  }
  2576  
  2577  func (m *StartReplicationResponse) MarshalVT() (dAtA []byte, err error) {
  2578  	if m == nil {
  2579  		return nil, nil
  2580  	}
  2581  	size := m.SizeVT()
  2582  	dAtA = make([]byte, size)
  2583  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2584  	if err != nil {
  2585  		return nil, err
  2586  	}
  2587  	return dAtA[:n], nil
  2588  }
  2589  
  2590  func (m *StartReplicationResponse) MarshalToVT(dAtA []byte) (int, error) {
  2591  	size := m.SizeVT()
  2592  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2593  }
  2594  
  2595  func (m *StartReplicationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2596  	if m == nil {
  2597  		return 0, nil
  2598  	}
  2599  	i := len(dAtA)
  2600  	_ = i
  2601  	var l int
  2602  	_ = l
  2603  	if m.unknownFields != nil {
  2604  		i -= len(m.unknownFields)
  2605  		copy(dAtA[i:], m.unknownFields)
  2606  	}
  2607  	return len(dAtA) - i, nil
  2608  }
  2609  
  2610  func (m *StartReplicationUntilAfterRequest) MarshalVT() (dAtA []byte, err error) {
  2611  	if m == nil {
  2612  		return nil, nil
  2613  	}
  2614  	size := m.SizeVT()
  2615  	dAtA = make([]byte, size)
  2616  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2617  	if err != nil {
  2618  		return nil, err
  2619  	}
  2620  	return dAtA[:n], nil
  2621  }
  2622  
  2623  func (m *StartReplicationUntilAfterRequest) MarshalToVT(dAtA []byte) (int, error) {
  2624  	size := m.SizeVT()
  2625  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2626  }
  2627  
  2628  func (m *StartReplicationUntilAfterRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2629  	if m == nil {
  2630  		return 0, nil
  2631  	}
  2632  	i := len(dAtA)
  2633  	_ = i
  2634  	var l int
  2635  	_ = l
  2636  	if m.unknownFields != nil {
  2637  		i -= len(m.unknownFields)
  2638  		copy(dAtA[i:], m.unknownFields)
  2639  	}
  2640  	if m.WaitTimeout != 0 {
  2641  		i = encodeVarint(dAtA, i, uint64(m.WaitTimeout))
  2642  		i--
  2643  		dAtA[i] = 0x10
  2644  	}
  2645  	if len(m.Position) > 0 {
  2646  		i -= len(m.Position)
  2647  		copy(dAtA[i:], m.Position)
  2648  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  2649  		i--
  2650  		dAtA[i] = 0xa
  2651  	}
  2652  	return len(dAtA) - i, nil
  2653  }
  2654  
  2655  func (m *StartReplicationUntilAfterResponse) MarshalVT() (dAtA []byte, err error) {
  2656  	if m == nil {
  2657  		return nil, nil
  2658  	}
  2659  	size := m.SizeVT()
  2660  	dAtA = make([]byte, size)
  2661  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2662  	if err != nil {
  2663  		return nil, err
  2664  	}
  2665  	return dAtA[:n], nil
  2666  }
  2667  
  2668  func (m *StartReplicationUntilAfterResponse) MarshalToVT(dAtA []byte) (int, error) {
  2669  	size := m.SizeVT()
  2670  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2671  }
  2672  
  2673  func (m *StartReplicationUntilAfterResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2674  	if m == nil {
  2675  		return 0, nil
  2676  	}
  2677  	i := len(dAtA)
  2678  	_ = i
  2679  	var l int
  2680  	_ = l
  2681  	if m.unknownFields != nil {
  2682  		i -= len(m.unknownFields)
  2683  		copy(dAtA[i:], m.unknownFields)
  2684  	}
  2685  	return len(dAtA) - i, nil
  2686  }
  2687  
  2688  func (m *GetReplicasRequest) MarshalVT() (dAtA []byte, err error) {
  2689  	if m == nil {
  2690  		return nil, nil
  2691  	}
  2692  	size := m.SizeVT()
  2693  	dAtA = make([]byte, size)
  2694  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2695  	if err != nil {
  2696  		return nil, err
  2697  	}
  2698  	return dAtA[:n], nil
  2699  }
  2700  
  2701  func (m *GetReplicasRequest) MarshalToVT(dAtA []byte) (int, error) {
  2702  	size := m.SizeVT()
  2703  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2704  }
  2705  
  2706  func (m *GetReplicasRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2707  	if m == nil {
  2708  		return 0, nil
  2709  	}
  2710  	i := len(dAtA)
  2711  	_ = i
  2712  	var l int
  2713  	_ = l
  2714  	if m.unknownFields != nil {
  2715  		i -= len(m.unknownFields)
  2716  		copy(dAtA[i:], m.unknownFields)
  2717  	}
  2718  	return len(dAtA) - i, nil
  2719  }
  2720  
  2721  func (m *GetReplicasResponse) MarshalVT() (dAtA []byte, err error) {
  2722  	if m == nil {
  2723  		return nil, nil
  2724  	}
  2725  	size := m.SizeVT()
  2726  	dAtA = make([]byte, size)
  2727  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2728  	if err != nil {
  2729  		return nil, err
  2730  	}
  2731  	return dAtA[:n], nil
  2732  }
  2733  
  2734  func (m *GetReplicasResponse) MarshalToVT(dAtA []byte) (int, error) {
  2735  	size := m.SizeVT()
  2736  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2737  }
  2738  
  2739  func (m *GetReplicasResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2740  	if m == nil {
  2741  		return 0, nil
  2742  	}
  2743  	i := len(dAtA)
  2744  	_ = i
  2745  	var l int
  2746  	_ = l
  2747  	if m.unknownFields != nil {
  2748  		i -= len(m.unknownFields)
  2749  		copy(dAtA[i:], m.unknownFields)
  2750  	}
  2751  	if len(m.Addrs) > 0 {
  2752  		for iNdEx := len(m.Addrs) - 1; iNdEx >= 0; iNdEx-- {
  2753  			i -= len(m.Addrs[iNdEx])
  2754  			copy(dAtA[i:], m.Addrs[iNdEx])
  2755  			i = encodeVarint(dAtA, i, uint64(len(m.Addrs[iNdEx])))
  2756  			i--
  2757  			dAtA[i] = 0xa
  2758  		}
  2759  	}
  2760  	return len(dAtA) - i, nil
  2761  }
  2762  
  2763  func (m *ResetReplicationRequest) MarshalVT() (dAtA []byte, err error) {
  2764  	if m == nil {
  2765  		return nil, nil
  2766  	}
  2767  	size := m.SizeVT()
  2768  	dAtA = make([]byte, size)
  2769  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2770  	if err != nil {
  2771  		return nil, err
  2772  	}
  2773  	return dAtA[:n], nil
  2774  }
  2775  
  2776  func (m *ResetReplicationRequest) MarshalToVT(dAtA []byte) (int, error) {
  2777  	size := m.SizeVT()
  2778  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2779  }
  2780  
  2781  func (m *ResetReplicationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2782  	if m == nil {
  2783  		return 0, nil
  2784  	}
  2785  	i := len(dAtA)
  2786  	_ = i
  2787  	var l int
  2788  	_ = l
  2789  	if m.unknownFields != nil {
  2790  		i -= len(m.unknownFields)
  2791  		copy(dAtA[i:], m.unknownFields)
  2792  	}
  2793  	return len(dAtA) - i, nil
  2794  }
  2795  
  2796  func (m *ResetReplicationResponse) MarshalVT() (dAtA []byte, err error) {
  2797  	if m == nil {
  2798  		return nil, nil
  2799  	}
  2800  	size := m.SizeVT()
  2801  	dAtA = make([]byte, size)
  2802  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2803  	if err != nil {
  2804  		return nil, err
  2805  	}
  2806  	return dAtA[:n], nil
  2807  }
  2808  
  2809  func (m *ResetReplicationResponse) MarshalToVT(dAtA []byte) (int, error) {
  2810  	size := m.SizeVT()
  2811  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2812  }
  2813  
  2814  func (m *ResetReplicationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2815  	if m == nil {
  2816  		return 0, nil
  2817  	}
  2818  	i := len(dAtA)
  2819  	_ = i
  2820  	var l int
  2821  	_ = l
  2822  	if m.unknownFields != nil {
  2823  		i -= len(m.unknownFields)
  2824  		copy(dAtA[i:], m.unknownFields)
  2825  	}
  2826  	return len(dAtA) - i, nil
  2827  }
  2828  
  2829  func (m *VReplicationExecRequest) MarshalVT() (dAtA []byte, err error) {
  2830  	if m == nil {
  2831  		return nil, nil
  2832  	}
  2833  	size := m.SizeVT()
  2834  	dAtA = make([]byte, size)
  2835  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2836  	if err != nil {
  2837  		return nil, err
  2838  	}
  2839  	return dAtA[:n], nil
  2840  }
  2841  
  2842  func (m *VReplicationExecRequest) MarshalToVT(dAtA []byte) (int, error) {
  2843  	size := m.SizeVT()
  2844  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2845  }
  2846  
  2847  func (m *VReplicationExecRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2848  	if m == nil {
  2849  		return 0, nil
  2850  	}
  2851  	i := len(dAtA)
  2852  	_ = i
  2853  	var l int
  2854  	_ = l
  2855  	if m.unknownFields != nil {
  2856  		i -= len(m.unknownFields)
  2857  		copy(dAtA[i:], m.unknownFields)
  2858  	}
  2859  	if len(m.Query) > 0 {
  2860  		i -= len(m.Query)
  2861  		copy(dAtA[i:], m.Query)
  2862  		i = encodeVarint(dAtA, i, uint64(len(m.Query)))
  2863  		i--
  2864  		dAtA[i] = 0xa
  2865  	}
  2866  	return len(dAtA) - i, nil
  2867  }
  2868  
  2869  func (m *VReplicationExecResponse) MarshalVT() (dAtA []byte, err error) {
  2870  	if m == nil {
  2871  		return nil, nil
  2872  	}
  2873  	size := m.SizeVT()
  2874  	dAtA = make([]byte, size)
  2875  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2876  	if err != nil {
  2877  		return nil, err
  2878  	}
  2879  	return dAtA[:n], nil
  2880  }
  2881  
  2882  func (m *VReplicationExecResponse) MarshalToVT(dAtA []byte) (int, error) {
  2883  	size := m.SizeVT()
  2884  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2885  }
  2886  
  2887  func (m *VReplicationExecResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2888  	if m == nil {
  2889  		return 0, nil
  2890  	}
  2891  	i := len(dAtA)
  2892  	_ = i
  2893  	var l int
  2894  	_ = l
  2895  	if m.unknownFields != nil {
  2896  		i -= len(m.unknownFields)
  2897  		copy(dAtA[i:], m.unknownFields)
  2898  	}
  2899  	if m.Result != nil {
  2900  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  2901  		if err != nil {
  2902  			return 0, err
  2903  		}
  2904  		i -= size
  2905  		i = encodeVarint(dAtA, i, uint64(size))
  2906  		i--
  2907  		dAtA[i] = 0xa
  2908  	}
  2909  	return len(dAtA) - i, nil
  2910  }
  2911  
  2912  func (m *VReplicationWaitForPosRequest) MarshalVT() (dAtA []byte, err error) {
  2913  	if m == nil {
  2914  		return nil, nil
  2915  	}
  2916  	size := m.SizeVT()
  2917  	dAtA = make([]byte, size)
  2918  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2919  	if err != nil {
  2920  		return nil, err
  2921  	}
  2922  	return dAtA[:n], nil
  2923  }
  2924  
  2925  func (m *VReplicationWaitForPosRequest) MarshalToVT(dAtA []byte) (int, error) {
  2926  	size := m.SizeVT()
  2927  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2928  }
  2929  
  2930  func (m *VReplicationWaitForPosRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2931  	if m == nil {
  2932  		return 0, nil
  2933  	}
  2934  	i := len(dAtA)
  2935  	_ = i
  2936  	var l int
  2937  	_ = l
  2938  	if m.unknownFields != nil {
  2939  		i -= len(m.unknownFields)
  2940  		copy(dAtA[i:], m.unknownFields)
  2941  	}
  2942  	if len(m.Position) > 0 {
  2943  		i -= len(m.Position)
  2944  		copy(dAtA[i:], m.Position)
  2945  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  2946  		i--
  2947  		dAtA[i] = 0x12
  2948  	}
  2949  	if m.Id != 0 {
  2950  		i = encodeVarint(dAtA, i, uint64(m.Id))
  2951  		i--
  2952  		dAtA[i] = 0x8
  2953  	}
  2954  	return len(dAtA) - i, nil
  2955  }
  2956  
  2957  func (m *VReplicationWaitForPosResponse) MarshalVT() (dAtA []byte, err error) {
  2958  	if m == nil {
  2959  		return nil, nil
  2960  	}
  2961  	size := m.SizeVT()
  2962  	dAtA = make([]byte, size)
  2963  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2964  	if err != nil {
  2965  		return nil, err
  2966  	}
  2967  	return dAtA[:n], nil
  2968  }
  2969  
  2970  func (m *VReplicationWaitForPosResponse) MarshalToVT(dAtA []byte) (int, error) {
  2971  	size := m.SizeVT()
  2972  	return m.MarshalToSizedBufferVT(dAtA[:size])
  2973  }
  2974  
  2975  func (m *VReplicationWaitForPosResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  2976  	if m == nil {
  2977  		return 0, nil
  2978  	}
  2979  	i := len(dAtA)
  2980  	_ = i
  2981  	var l int
  2982  	_ = l
  2983  	if m.unknownFields != nil {
  2984  		i -= len(m.unknownFields)
  2985  		copy(dAtA[i:], m.unknownFields)
  2986  	}
  2987  	return len(dAtA) - i, nil
  2988  }
  2989  
  2990  func (m *InitPrimaryRequest) MarshalVT() (dAtA []byte, err error) {
  2991  	if m == nil {
  2992  		return nil, nil
  2993  	}
  2994  	size := m.SizeVT()
  2995  	dAtA = make([]byte, size)
  2996  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  2997  	if err != nil {
  2998  		return nil, err
  2999  	}
  3000  	return dAtA[:n], nil
  3001  }
  3002  
  3003  func (m *InitPrimaryRequest) MarshalToVT(dAtA []byte) (int, error) {
  3004  	size := m.SizeVT()
  3005  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3006  }
  3007  
  3008  func (m *InitPrimaryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3009  	if m == nil {
  3010  		return 0, nil
  3011  	}
  3012  	i := len(dAtA)
  3013  	_ = i
  3014  	var l int
  3015  	_ = l
  3016  	if m.unknownFields != nil {
  3017  		i -= len(m.unknownFields)
  3018  		copy(dAtA[i:], m.unknownFields)
  3019  	}
  3020  	if m.SemiSync {
  3021  		i--
  3022  		if m.SemiSync {
  3023  			dAtA[i] = 1
  3024  		} else {
  3025  			dAtA[i] = 0
  3026  		}
  3027  		i--
  3028  		dAtA[i] = 0x8
  3029  	}
  3030  	return len(dAtA) - i, nil
  3031  }
  3032  
  3033  func (m *InitPrimaryResponse) MarshalVT() (dAtA []byte, err error) {
  3034  	if m == nil {
  3035  		return nil, nil
  3036  	}
  3037  	size := m.SizeVT()
  3038  	dAtA = make([]byte, size)
  3039  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3040  	if err != nil {
  3041  		return nil, err
  3042  	}
  3043  	return dAtA[:n], nil
  3044  }
  3045  
  3046  func (m *InitPrimaryResponse) MarshalToVT(dAtA []byte) (int, error) {
  3047  	size := m.SizeVT()
  3048  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3049  }
  3050  
  3051  func (m *InitPrimaryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3052  	if m == nil {
  3053  		return 0, nil
  3054  	}
  3055  	i := len(dAtA)
  3056  	_ = i
  3057  	var l int
  3058  	_ = l
  3059  	if m.unknownFields != nil {
  3060  		i -= len(m.unknownFields)
  3061  		copy(dAtA[i:], m.unknownFields)
  3062  	}
  3063  	if len(m.Position) > 0 {
  3064  		i -= len(m.Position)
  3065  		copy(dAtA[i:], m.Position)
  3066  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  3067  		i--
  3068  		dAtA[i] = 0xa
  3069  	}
  3070  	return len(dAtA) - i, nil
  3071  }
  3072  
  3073  func (m *PopulateReparentJournalRequest) MarshalVT() (dAtA []byte, err error) {
  3074  	if m == nil {
  3075  		return nil, nil
  3076  	}
  3077  	size := m.SizeVT()
  3078  	dAtA = make([]byte, size)
  3079  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3080  	if err != nil {
  3081  		return nil, err
  3082  	}
  3083  	return dAtA[:n], nil
  3084  }
  3085  
  3086  func (m *PopulateReparentJournalRequest) MarshalToVT(dAtA []byte) (int, error) {
  3087  	size := m.SizeVT()
  3088  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3089  }
  3090  
  3091  func (m *PopulateReparentJournalRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3092  	if m == nil {
  3093  		return 0, nil
  3094  	}
  3095  	i := len(dAtA)
  3096  	_ = i
  3097  	var l int
  3098  	_ = l
  3099  	if m.unknownFields != nil {
  3100  		i -= len(m.unknownFields)
  3101  		copy(dAtA[i:], m.unknownFields)
  3102  	}
  3103  	if len(m.ReplicationPosition) > 0 {
  3104  		i -= len(m.ReplicationPosition)
  3105  		copy(dAtA[i:], m.ReplicationPosition)
  3106  		i = encodeVarint(dAtA, i, uint64(len(m.ReplicationPosition)))
  3107  		i--
  3108  		dAtA[i] = 0x22
  3109  	}
  3110  	if m.PrimaryAlias != nil {
  3111  		size, err := m.PrimaryAlias.MarshalToSizedBufferVT(dAtA[:i])
  3112  		if err != nil {
  3113  			return 0, err
  3114  		}
  3115  		i -= size
  3116  		i = encodeVarint(dAtA, i, uint64(size))
  3117  		i--
  3118  		dAtA[i] = 0x1a
  3119  	}
  3120  	if len(m.ActionName) > 0 {
  3121  		i -= len(m.ActionName)
  3122  		copy(dAtA[i:], m.ActionName)
  3123  		i = encodeVarint(dAtA, i, uint64(len(m.ActionName)))
  3124  		i--
  3125  		dAtA[i] = 0x12
  3126  	}
  3127  	if m.TimeCreatedNs != 0 {
  3128  		i = encodeVarint(dAtA, i, uint64(m.TimeCreatedNs))
  3129  		i--
  3130  		dAtA[i] = 0x8
  3131  	}
  3132  	return len(dAtA) - i, nil
  3133  }
  3134  
  3135  func (m *PopulateReparentJournalResponse) MarshalVT() (dAtA []byte, err error) {
  3136  	if m == nil {
  3137  		return nil, nil
  3138  	}
  3139  	size := m.SizeVT()
  3140  	dAtA = make([]byte, size)
  3141  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3142  	if err != nil {
  3143  		return nil, err
  3144  	}
  3145  	return dAtA[:n], nil
  3146  }
  3147  
  3148  func (m *PopulateReparentJournalResponse) MarshalToVT(dAtA []byte) (int, error) {
  3149  	size := m.SizeVT()
  3150  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3151  }
  3152  
  3153  func (m *PopulateReparentJournalResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3154  	if m == nil {
  3155  		return 0, nil
  3156  	}
  3157  	i := len(dAtA)
  3158  	_ = i
  3159  	var l int
  3160  	_ = l
  3161  	if m.unknownFields != nil {
  3162  		i -= len(m.unknownFields)
  3163  		copy(dAtA[i:], m.unknownFields)
  3164  	}
  3165  	return len(dAtA) - i, nil
  3166  }
  3167  
  3168  func (m *InitReplicaRequest) MarshalVT() (dAtA []byte, err error) {
  3169  	if m == nil {
  3170  		return nil, nil
  3171  	}
  3172  	size := m.SizeVT()
  3173  	dAtA = make([]byte, size)
  3174  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3175  	if err != nil {
  3176  		return nil, err
  3177  	}
  3178  	return dAtA[:n], nil
  3179  }
  3180  
  3181  func (m *InitReplicaRequest) MarshalToVT(dAtA []byte) (int, error) {
  3182  	size := m.SizeVT()
  3183  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3184  }
  3185  
  3186  func (m *InitReplicaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3187  	if m == nil {
  3188  		return 0, nil
  3189  	}
  3190  	i := len(dAtA)
  3191  	_ = i
  3192  	var l int
  3193  	_ = l
  3194  	if m.unknownFields != nil {
  3195  		i -= len(m.unknownFields)
  3196  		copy(dAtA[i:], m.unknownFields)
  3197  	}
  3198  	if m.SemiSync {
  3199  		i--
  3200  		if m.SemiSync {
  3201  			dAtA[i] = 1
  3202  		} else {
  3203  			dAtA[i] = 0
  3204  		}
  3205  		i--
  3206  		dAtA[i] = 0x20
  3207  	}
  3208  	if m.TimeCreatedNs != 0 {
  3209  		i = encodeVarint(dAtA, i, uint64(m.TimeCreatedNs))
  3210  		i--
  3211  		dAtA[i] = 0x18
  3212  	}
  3213  	if len(m.ReplicationPosition) > 0 {
  3214  		i -= len(m.ReplicationPosition)
  3215  		copy(dAtA[i:], m.ReplicationPosition)
  3216  		i = encodeVarint(dAtA, i, uint64(len(m.ReplicationPosition)))
  3217  		i--
  3218  		dAtA[i] = 0x12
  3219  	}
  3220  	if m.Parent != nil {
  3221  		size, err := m.Parent.MarshalToSizedBufferVT(dAtA[:i])
  3222  		if err != nil {
  3223  			return 0, err
  3224  		}
  3225  		i -= size
  3226  		i = encodeVarint(dAtA, i, uint64(size))
  3227  		i--
  3228  		dAtA[i] = 0xa
  3229  	}
  3230  	return len(dAtA) - i, nil
  3231  }
  3232  
  3233  func (m *InitReplicaResponse) MarshalVT() (dAtA []byte, err error) {
  3234  	if m == nil {
  3235  		return nil, nil
  3236  	}
  3237  	size := m.SizeVT()
  3238  	dAtA = make([]byte, size)
  3239  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3240  	if err != nil {
  3241  		return nil, err
  3242  	}
  3243  	return dAtA[:n], nil
  3244  }
  3245  
  3246  func (m *InitReplicaResponse) MarshalToVT(dAtA []byte) (int, error) {
  3247  	size := m.SizeVT()
  3248  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3249  }
  3250  
  3251  func (m *InitReplicaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3252  	if m == nil {
  3253  		return 0, nil
  3254  	}
  3255  	i := len(dAtA)
  3256  	_ = i
  3257  	var l int
  3258  	_ = l
  3259  	if m.unknownFields != nil {
  3260  		i -= len(m.unknownFields)
  3261  		copy(dAtA[i:], m.unknownFields)
  3262  	}
  3263  	return len(dAtA) - i, nil
  3264  }
  3265  
  3266  func (m *DemotePrimaryRequest) MarshalVT() (dAtA []byte, err error) {
  3267  	if m == nil {
  3268  		return nil, nil
  3269  	}
  3270  	size := m.SizeVT()
  3271  	dAtA = make([]byte, size)
  3272  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3273  	if err != nil {
  3274  		return nil, err
  3275  	}
  3276  	return dAtA[:n], nil
  3277  }
  3278  
  3279  func (m *DemotePrimaryRequest) MarshalToVT(dAtA []byte) (int, error) {
  3280  	size := m.SizeVT()
  3281  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3282  }
  3283  
  3284  func (m *DemotePrimaryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3285  	if m == nil {
  3286  		return 0, nil
  3287  	}
  3288  	i := len(dAtA)
  3289  	_ = i
  3290  	var l int
  3291  	_ = l
  3292  	if m.unknownFields != nil {
  3293  		i -= len(m.unknownFields)
  3294  		copy(dAtA[i:], m.unknownFields)
  3295  	}
  3296  	return len(dAtA) - i, nil
  3297  }
  3298  
  3299  func (m *DemotePrimaryResponse) MarshalVT() (dAtA []byte, err error) {
  3300  	if m == nil {
  3301  		return nil, nil
  3302  	}
  3303  	size := m.SizeVT()
  3304  	dAtA = make([]byte, size)
  3305  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3306  	if err != nil {
  3307  		return nil, err
  3308  	}
  3309  	return dAtA[:n], nil
  3310  }
  3311  
  3312  func (m *DemotePrimaryResponse) MarshalToVT(dAtA []byte) (int, error) {
  3313  	size := m.SizeVT()
  3314  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3315  }
  3316  
  3317  func (m *DemotePrimaryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3318  	if m == nil {
  3319  		return 0, nil
  3320  	}
  3321  	i := len(dAtA)
  3322  	_ = i
  3323  	var l int
  3324  	_ = l
  3325  	if m.unknownFields != nil {
  3326  		i -= len(m.unknownFields)
  3327  		copy(dAtA[i:], m.unknownFields)
  3328  	}
  3329  	if m.PrimaryStatus != nil {
  3330  		size, err := m.PrimaryStatus.MarshalToSizedBufferVT(dAtA[:i])
  3331  		if err != nil {
  3332  			return 0, err
  3333  		}
  3334  		i -= size
  3335  		i = encodeVarint(dAtA, i, uint64(size))
  3336  		i--
  3337  		dAtA[i] = 0x12
  3338  	}
  3339  	return len(dAtA) - i, nil
  3340  }
  3341  
  3342  func (m *UndoDemotePrimaryRequest) MarshalVT() (dAtA []byte, err error) {
  3343  	if m == nil {
  3344  		return nil, nil
  3345  	}
  3346  	size := m.SizeVT()
  3347  	dAtA = make([]byte, size)
  3348  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3349  	if err != nil {
  3350  		return nil, err
  3351  	}
  3352  	return dAtA[:n], nil
  3353  }
  3354  
  3355  func (m *UndoDemotePrimaryRequest) MarshalToVT(dAtA []byte) (int, error) {
  3356  	size := m.SizeVT()
  3357  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3358  }
  3359  
  3360  func (m *UndoDemotePrimaryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3361  	if m == nil {
  3362  		return 0, nil
  3363  	}
  3364  	i := len(dAtA)
  3365  	_ = i
  3366  	var l int
  3367  	_ = l
  3368  	if m.unknownFields != nil {
  3369  		i -= len(m.unknownFields)
  3370  		copy(dAtA[i:], m.unknownFields)
  3371  	}
  3372  	if m.SemiSync {
  3373  		i--
  3374  		if m.SemiSync {
  3375  			dAtA[i] = 1
  3376  		} else {
  3377  			dAtA[i] = 0
  3378  		}
  3379  		i--
  3380  		dAtA[i] = 0x8
  3381  	}
  3382  	return len(dAtA) - i, nil
  3383  }
  3384  
  3385  func (m *UndoDemotePrimaryResponse) 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 *UndoDemotePrimaryResponse) MarshalToVT(dAtA []byte) (int, error) {
  3399  	size := m.SizeVT()
  3400  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3401  }
  3402  
  3403  func (m *UndoDemotePrimaryResponse) 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  	return len(dAtA) - i, nil
  3416  }
  3417  
  3418  func (m *ReplicaWasPromotedRequest) MarshalVT() (dAtA []byte, err error) {
  3419  	if m == nil {
  3420  		return nil, nil
  3421  	}
  3422  	size := m.SizeVT()
  3423  	dAtA = make([]byte, size)
  3424  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3425  	if err != nil {
  3426  		return nil, err
  3427  	}
  3428  	return dAtA[:n], nil
  3429  }
  3430  
  3431  func (m *ReplicaWasPromotedRequest) MarshalToVT(dAtA []byte) (int, error) {
  3432  	size := m.SizeVT()
  3433  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3434  }
  3435  
  3436  func (m *ReplicaWasPromotedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3437  	if m == nil {
  3438  		return 0, nil
  3439  	}
  3440  	i := len(dAtA)
  3441  	_ = i
  3442  	var l int
  3443  	_ = l
  3444  	if m.unknownFields != nil {
  3445  		i -= len(m.unknownFields)
  3446  		copy(dAtA[i:], m.unknownFields)
  3447  	}
  3448  	return len(dAtA) - i, nil
  3449  }
  3450  
  3451  func (m *ReplicaWasPromotedResponse) MarshalVT() (dAtA []byte, err error) {
  3452  	if m == nil {
  3453  		return nil, nil
  3454  	}
  3455  	size := m.SizeVT()
  3456  	dAtA = make([]byte, size)
  3457  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3458  	if err != nil {
  3459  		return nil, err
  3460  	}
  3461  	return dAtA[:n], nil
  3462  }
  3463  
  3464  func (m *ReplicaWasPromotedResponse) MarshalToVT(dAtA []byte) (int, error) {
  3465  	size := m.SizeVT()
  3466  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3467  }
  3468  
  3469  func (m *ReplicaWasPromotedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3470  	if m == nil {
  3471  		return 0, nil
  3472  	}
  3473  	i := len(dAtA)
  3474  	_ = i
  3475  	var l int
  3476  	_ = l
  3477  	if m.unknownFields != nil {
  3478  		i -= len(m.unknownFields)
  3479  		copy(dAtA[i:], m.unknownFields)
  3480  	}
  3481  	return len(dAtA) - i, nil
  3482  }
  3483  
  3484  func (m *ResetReplicationParametersRequest) MarshalVT() (dAtA []byte, err error) {
  3485  	if m == nil {
  3486  		return nil, nil
  3487  	}
  3488  	size := m.SizeVT()
  3489  	dAtA = make([]byte, size)
  3490  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3491  	if err != nil {
  3492  		return nil, err
  3493  	}
  3494  	return dAtA[:n], nil
  3495  }
  3496  
  3497  func (m *ResetReplicationParametersRequest) MarshalToVT(dAtA []byte) (int, error) {
  3498  	size := m.SizeVT()
  3499  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3500  }
  3501  
  3502  func (m *ResetReplicationParametersRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3503  	if m == nil {
  3504  		return 0, nil
  3505  	}
  3506  	i := len(dAtA)
  3507  	_ = i
  3508  	var l int
  3509  	_ = l
  3510  	if m.unknownFields != nil {
  3511  		i -= len(m.unknownFields)
  3512  		copy(dAtA[i:], m.unknownFields)
  3513  	}
  3514  	return len(dAtA) - i, nil
  3515  }
  3516  
  3517  func (m *ResetReplicationParametersResponse) MarshalVT() (dAtA []byte, err error) {
  3518  	if m == nil {
  3519  		return nil, nil
  3520  	}
  3521  	size := m.SizeVT()
  3522  	dAtA = make([]byte, size)
  3523  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3524  	if err != nil {
  3525  		return nil, err
  3526  	}
  3527  	return dAtA[:n], nil
  3528  }
  3529  
  3530  func (m *ResetReplicationParametersResponse) MarshalToVT(dAtA []byte) (int, error) {
  3531  	size := m.SizeVT()
  3532  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3533  }
  3534  
  3535  func (m *ResetReplicationParametersResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3536  	if m == nil {
  3537  		return 0, nil
  3538  	}
  3539  	i := len(dAtA)
  3540  	_ = i
  3541  	var l int
  3542  	_ = l
  3543  	if m.unknownFields != nil {
  3544  		i -= len(m.unknownFields)
  3545  		copy(dAtA[i:], m.unknownFields)
  3546  	}
  3547  	return len(dAtA) - i, nil
  3548  }
  3549  
  3550  func (m *FullStatusRequest) MarshalVT() (dAtA []byte, err error) {
  3551  	if m == nil {
  3552  		return nil, nil
  3553  	}
  3554  	size := m.SizeVT()
  3555  	dAtA = make([]byte, size)
  3556  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3557  	if err != nil {
  3558  		return nil, err
  3559  	}
  3560  	return dAtA[:n], nil
  3561  }
  3562  
  3563  func (m *FullStatusRequest) MarshalToVT(dAtA []byte) (int, error) {
  3564  	size := m.SizeVT()
  3565  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3566  }
  3567  
  3568  func (m *FullStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3569  	if m == nil {
  3570  		return 0, nil
  3571  	}
  3572  	i := len(dAtA)
  3573  	_ = i
  3574  	var l int
  3575  	_ = l
  3576  	if m.unknownFields != nil {
  3577  		i -= len(m.unknownFields)
  3578  		copy(dAtA[i:], m.unknownFields)
  3579  	}
  3580  	return len(dAtA) - i, nil
  3581  }
  3582  
  3583  func (m *FullStatusResponse) MarshalVT() (dAtA []byte, err error) {
  3584  	if m == nil {
  3585  		return nil, nil
  3586  	}
  3587  	size := m.SizeVT()
  3588  	dAtA = make([]byte, size)
  3589  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3590  	if err != nil {
  3591  		return nil, err
  3592  	}
  3593  	return dAtA[:n], nil
  3594  }
  3595  
  3596  func (m *FullStatusResponse) MarshalToVT(dAtA []byte) (int, error) {
  3597  	size := m.SizeVT()
  3598  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3599  }
  3600  
  3601  func (m *FullStatusResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3602  	if m == nil {
  3603  		return 0, nil
  3604  	}
  3605  	i := len(dAtA)
  3606  	_ = i
  3607  	var l int
  3608  	_ = l
  3609  	if m.unknownFields != nil {
  3610  		i -= len(m.unknownFields)
  3611  		copy(dAtA[i:], m.unknownFields)
  3612  	}
  3613  	if m.Status != nil {
  3614  		size, err := m.Status.MarshalToSizedBufferVT(dAtA[:i])
  3615  		if err != nil {
  3616  			return 0, err
  3617  		}
  3618  		i -= size
  3619  		i = encodeVarint(dAtA, i, uint64(size))
  3620  		i--
  3621  		dAtA[i] = 0xa
  3622  	}
  3623  	return len(dAtA) - i, nil
  3624  }
  3625  
  3626  func (m *SetReplicationSourceRequest) MarshalVT() (dAtA []byte, err error) {
  3627  	if m == nil {
  3628  		return nil, nil
  3629  	}
  3630  	size := m.SizeVT()
  3631  	dAtA = make([]byte, size)
  3632  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3633  	if err != nil {
  3634  		return nil, err
  3635  	}
  3636  	return dAtA[:n], nil
  3637  }
  3638  
  3639  func (m *SetReplicationSourceRequest) MarshalToVT(dAtA []byte) (int, error) {
  3640  	size := m.SizeVT()
  3641  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3642  }
  3643  
  3644  func (m *SetReplicationSourceRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3645  	if m == nil {
  3646  		return 0, nil
  3647  	}
  3648  	i := len(dAtA)
  3649  	_ = i
  3650  	var l int
  3651  	_ = l
  3652  	if m.unknownFields != nil {
  3653  		i -= len(m.unknownFields)
  3654  		copy(dAtA[i:], m.unknownFields)
  3655  	}
  3656  	if m.SemiSync {
  3657  		i--
  3658  		if m.SemiSync {
  3659  			dAtA[i] = 1
  3660  		} else {
  3661  			dAtA[i] = 0
  3662  		}
  3663  		i--
  3664  		dAtA[i] = 0x28
  3665  	}
  3666  	if len(m.WaitPosition) > 0 {
  3667  		i -= len(m.WaitPosition)
  3668  		copy(dAtA[i:], m.WaitPosition)
  3669  		i = encodeVarint(dAtA, i, uint64(len(m.WaitPosition)))
  3670  		i--
  3671  		dAtA[i] = 0x22
  3672  	}
  3673  	if m.ForceStartReplication {
  3674  		i--
  3675  		if m.ForceStartReplication {
  3676  			dAtA[i] = 1
  3677  		} else {
  3678  			dAtA[i] = 0
  3679  		}
  3680  		i--
  3681  		dAtA[i] = 0x18
  3682  	}
  3683  	if m.TimeCreatedNs != 0 {
  3684  		i = encodeVarint(dAtA, i, uint64(m.TimeCreatedNs))
  3685  		i--
  3686  		dAtA[i] = 0x10
  3687  	}
  3688  	if m.Parent != nil {
  3689  		size, err := m.Parent.MarshalToSizedBufferVT(dAtA[:i])
  3690  		if err != nil {
  3691  			return 0, err
  3692  		}
  3693  		i -= size
  3694  		i = encodeVarint(dAtA, i, uint64(size))
  3695  		i--
  3696  		dAtA[i] = 0xa
  3697  	}
  3698  	return len(dAtA) - i, nil
  3699  }
  3700  
  3701  func (m *SetReplicationSourceResponse) MarshalVT() (dAtA []byte, err error) {
  3702  	if m == nil {
  3703  		return nil, nil
  3704  	}
  3705  	size := m.SizeVT()
  3706  	dAtA = make([]byte, size)
  3707  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3708  	if err != nil {
  3709  		return nil, err
  3710  	}
  3711  	return dAtA[:n], nil
  3712  }
  3713  
  3714  func (m *SetReplicationSourceResponse) MarshalToVT(dAtA []byte) (int, error) {
  3715  	size := m.SizeVT()
  3716  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3717  }
  3718  
  3719  func (m *SetReplicationSourceResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3720  	if m == nil {
  3721  		return 0, nil
  3722  	}
  3723  	i := len(dAtA)
  3724  	_ = i
  3725  	var l int
  3726  	_ = l
  3727  	if m.unknownFields != nil {
  3728  		i -= len(m.unknownFields)
  3729  		copy(dAtA[i:], m.unknownFields)
  3730  	}
  3731  	return len(dAtA) - i, nil
  3732  }
  3733  
  3734  func (m *ReplicaWasRestartedRequest) MarshalVT() (dAtA []byte, err error) {
  3735  	if m == nil {
  3736  		return nil, nil
  3737  	}
  3738  	size := m.SizeVT()
  3739  	dAtA = make([]byte, size)
  3740  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3741  	if err != nil {
  3742  		return nil, err
  3743  	}
  3744  	return dAtA[:n], nil
  3745  }
  3746  
  3747  func (m *ReplicaWasRestartedRequest) MarshalToVT(dAtA []byte) (int, error) {
  3748  	size := m.SizeVT()
  3749  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3750  }
  3751  
  3752  func (m *ReplicaWasRestartedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3753  	if m == nil {
  3754  		return 0, nil
  3755  	}
  3756  	i := len(dAtA)
  3757  	_ = i
  3758  	var l int
  3759  	_ = l
  3760  	if m.unknownFields != nil {
  3761  		i -= len(m.unknownFields)
  3762  		copy(dAtA[i:], m.unknownFields)
  3763  	}
  3764  	if m.Parent != nil {
  3765  		size, err := m.Parent.MarshalToSizedBufferVT(dAtA[:i])
  3766  		if err != nil {
  3767  			return 0, err
  3768  		}
  3769  		i -= size
  3770  		i = encodeVarint(dAtA, i, uint64(size))
  3771  		i--
  3772  		dAtA[i] = 0xa
  3773  	}
  3774  	return len(dAtA) - i, nil
  3775  }
  3776  
  3777  func (m *ReplicaWasRestartedResponse) MarshalVT() (dAtA []byte, err error) {
  3778  	if m == nil {
  3779  		return nil, nil
  3780  	}
  3781  	size := m.SizeVT()
  3782  	dAtA = make([]byte, size)
  3783  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3784  	if err != nil {
  3785  		return nil, err
  3786  	}
  3787  	return dAtA[:n], nil
  3788  }
  3789  
  3790  func (m *ReplicaWasRestartedResponse) MarshalToVT(dAtA []byte) (int, error) {
  3791  	size := m.SizeVT()
  3792  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3793  }
  3794  
  3795  func (m *ReplicaWasRestartedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3796  	if m == nil {
  3797  		return 0, nil
  3798  	}
  3799  	i := len(dAtA)
  3800  	_ = i
  3801  	var l int
  3802  	_ = l
  3803  	if m.unknownFields != nil {
  3804  		i -= len(m.unknownFields)
  3805  		copy(dAtA[i:], m.unknownFields)
  3806  	}
  3807  	return len(dAtA) - i, nil
  3808  }
  3809  
  3810  func (m *StopReplicationAndGetStatusRequest) MarshalVT() (dAtA []byte, err error) {
  3811  	if m == nil {
  3812  		return nil, nil
  3813  	}
  3814  	size := m.SizeVT()
  3815  	dAtA = make([]byte, size)
  3816  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3817  	if err != nil {
  3818  		return nil, err
  3819  	}
  3820  	return dAtA[:n], nil
  3821  }
  3822  
  3823  func (m *StopReplicationAndGetStatusRequest) MarshalToVT(dAtA []byte) (int, error) {
  3824  	size := m.SizeVT()
  3825  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3826  }
  3827  
  3828  func (m *StopReplicationAndGetStatusRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3829  	if m == nil {
  3830  		return 0, nil
  3831  	}
  3832  	i := len(dAtA)
  3833  	_ = i
  3834  	var l int
  3835  	_ = l
  3836  	if m.unknownFields != nil {
  3837  		i -= len(m.unknownFields)
  3838  		copy(dAtA[i:], m.unknownFields)
  3839  	}
  3840  	if m.StopReplicationMode != 0 {
  3841  		i = encodeVarint(dAtA, i, uint64(m.StopReplicationMode))
  3842  		i--
  3843  		dAtA[i] = 0x8
  3844  	}
  3845  	return len(dAtA) - i, nil
  3846  }
  3847  
  3848  func (m *StopReplicationAndGetStatusResponse) MarshalVT() (dAtA []byte, err error) {
  3849  	if m == nil {
  3850  		return nil, nil
  3851  	}
  3852  	size := m.SizeVT()
  3853  	dAtA = make([]byte, size)
  3854  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3855  	if err != nil {
  3856  		return nil, err
  3857  	}
  3858  	return dAtA[:n], nil
  3859  }
  3860  
  3861  func (m *StopReplicationAndGetStatusResponse) MarshalToVT(dAtA []byte) (int, error) {
  3862  	size := m.SizeVT()
  3863  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3864  }
  3865  
  3866  func (m *StopReplicationAndGetStatusResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3867  	if m == nil {
  3868  		return 0, nil
  3869  	}
  3870  	i := len(dAtA)
  3871  	_ = i
  3872  	var l int
  3873  	_ = l
  3874  	if m.unknownFields != nil {
  3875  		i -= len(m.unknownFields)
  3876  		copy(dAtA[i:], m.unknownFields)
  3877  	}
  3878  	if m.Status != nil {
  3879  		size, err := m.Status.MarshalToSizedBufferVT(dAtA[:i])
  3880  		if err != nil {
  3881  			return 0, err
  3882  		}
  3883  		i -= size
  3884  		i = encodeVarint(dAtA, i, uint64(size))
  3885  		i--
  3886  		dAtA[i] = 0x12
  3887  	}
  3888  	return len(dAtA) - i, nil
  3889  }
  3890  
  3891  func (m *PromoteReplicaRequest) MarshalVT() (dAtA []byte, err error) {
  3892  	if m == nil {
  3893  		return nil, nil
  3894  	}
  3895  	size := m.SizeVT()
  3896  	dAtA = make([]byte, size)
  3897  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3898  	if err != nil {
  3899  		return nil, err
  3900  	}
  3901  	return dAtA[:n], nil
  3902  }
  3903  
  3904  func (m *PromoteReplicaRequest) MarshalToVT(dAtA []byte) (int, error) {
  3905  	size := m.SizeVT()
  3906  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3907  }
  3908  
  3909  func (m *PromoteReplicaRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3910  	if m == nil {
  3911  		return 0, nil
  3912  	}
  3913  	i := len(dAtA)
  3914  	_ = i
  3915  	var l int
  3916  	_ = l
  3917  	if m.unknownFields != nil {
  3918  		i -= len(m.unknownFields)
  3919  		copy(dAtA[i:], m.unknownFields)
  3920  	}
  3921  	if m.SemiSync {
  3922  		i--
  3923  		if m.SemiSync {
  3924  			dAtA[i] = 1
  3925  		} else {
  3926  			dAtA[i] = 0
  3927  		}
  3928  		i--
  3929  		dAtA[i] = 0x8
  3930  	}
  3931  	return len(dAtA) - i, nil
  3932  }
  3933  
  3934  func (m *PromoteReplicaResponse) MarshalVT() (dAtA []byte, err error) {
  3935  	if m == nil {
  3936  		return nil, nil
  3937  	}
  3938  	size := m.SizeVT()
  3939  	dAtA = make([]byte, size)
  3940  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3941  	if err != nil {
  3942  		return nil, err
  3943  	}
  3944  	return dAtA[:n], nil
  3945  }
  3946  
  3947  func (m *PromoteReplicaResponse) MarshalToVT(dAtA []byte) (int, error) {
  3948  	size := m.SizeVT()
  3949  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3950  }
  3951  
  3952  func (m *PromoteReplicaResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3953  	if m == nil {
  3954  		return 0, nil
  3955  	}
  3956  	i := len(dAtA)
  3957  	_ = i
  3958  	var l int
  3959  	_ = l
  3960  	if m.unknownFields != nil {
  3961  		i -= len(m.unknownFields)
  3962  		copy(dAtA[i:], m.unknownFields)
  3963  	}
  3964  	if len(m.Position) > 0 {
  3965  		i -= len(m.Position)
  3966  		copy(dAtA[i:], m.Position)
  3967  		i = encodeVarint(dAtA, i, uint64(len(m.Position)))
  3968  		i--
  3969  		dAtA[i] = 0xa
  3970  	}
  3971  	return len(dAtA) - i, nil
  3972  }
  3973  
  3974  func (m *BackupRequest) MarshalVT() (dAtA []byte, err error) {
  3975  	if m == nil {
  3976  		return nil, nil
  3977  	}
  3978  	size := m.SizeVT()
  3979  	dAtA = make([]byte, size)
  3980  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  3981  	if err != nil {
  3982  		return nil, err
  3983  	}
  3984  	return dAtA[:n], nil
  3985  }
  3986  
  3987  func (m *BackupRequest) MarshalToVT(dAtA []byte) (int, error) {
  3988  	size := m.SizeVT()
  3989  	return m.MarshalToSizedBufferVT(dAtA[:size])
  3990  }
  3991  
  3992  func (m *BackupRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  3993  	if m == nil {
  3994  		return 0, nil
  3995  	}
  3996  	i := len(dAtA)
  3997  	_ = i
  3998  	var l int
  3999  	_ = l
  4000  	if m.unknownFields != nil {
  4001  		i -= len(m.unknownFields)
  4002  		copy(dAtA[i:], m.unknownFields)
  4003  	}
  4004  	if len(m.IncrementalFromPos) > 0 {
  4005  		i -= len(m.IncrementalFromPos)
  4006  		copy(dAtA[i:], m.IncrementalFromPos)
  4007  		i = encodeVarint(dAtA, i, uint64(len(m.IncrementalFromPos)))
  4008  		i--
  4009  		dAtA[i] = 0x1a
  4010  	}
  4011  	if m.AllowPrimary {
  4012  		i--
  4013  		if m.AllowPrimary {
  4014  			dAtA[i] = 1
  4015  		} else {
  4016  			dAtA[i] = 0
  4017  		}
  4018  		i--
  4019  		dAtA[i] = 0x10
  4020  	}
  4021  	if m.Concurrency != 0 {
  4022  		i = encodeVarint(dAtA, i, uint64(m.Concurrency))
  4023  		i--
  4024  		dAtA[i] = 0x8
  4025  	}
  4026  	return len(dAtA) - i, nil
  4027  }
  4028  
  4029  func (m *BackupResponse) MarshalVT() (dAtA []byte, err error) {
  4030  	if m == nil {
  4031  		return nil, nil
  4032  	}
  4033  	size := m.SizeVT()
  4034  	dAtA = make([]byte, size)
  4035  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4036  	if err != nil {
  4037  		return nil, err
  4038  	}
  4039  	return dAtA[:n], nil
  4040  }
  4041  
  4042  func (m *BackupResponse) MarshalToVT(dAtA []byte) (int, error) {
  4043  	size := m.SizeVT()
  4044  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4045  }
  4046  
  4047  func (m *BackupResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4048  	if m == nil {
  4049  		return 0, nil
  4050  	}
  4051  	i := len(dAtA)
  4052  	_ = i
  4053  	var l int
  4054  	_ = l
  4055  	if m.unknownFields != nil {
  4056  		i -= len(m.unknownFields)
  4057  		copy(dAtA[i:], m.unknownFields)
  4058  	}
  4059  	if m.Event != nil {
  4060  		size, err := m.Event.MarshalToSizedBufferVT(dAtA[:i])
  4061  		if err != nil {
  4062  			return 0, err
  4063  		}
  4064  		i -= size
  4065  		i = encodeVarint(dAtA, i, uint64(size))
  4066  		i--
  4067  		dAtA[i] = 0xa
  4068  	}
  4069  	return len(dAtA) - i, nil
  4070  }
  4071  
  4072  func (m *RestoreFromBackupRequest) MarshalVT() (dAtA []byte, err error) {
  4073  	if m == nil {
  4074  		return nil, nil
  4075  	}
  4076  	size := m.SizeVT()
  4077  	dAtA = make([]byte, size)
  4078  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4079  	if err != nil {
  4080  		return nil, err
  4081  	}
  4082  	return dAtA[:n], nil
  4083  }
  4084  
  4085  func (m *RestoreFromBackupRequest) MarshalToVT(dAtA []byte) (int, error) {
  4086  	size := m.SizeVT()
  4087  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4088  }
  4089  
  4090  func (m *RestoreFromBackupRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4091  	if m == nil {
  4092  		return 0, nil
  4093  	}
  4094  	i := len(dAtA)
  4095  	_ = i
  4096  	var l int
  4097  	_ = l
  4098  	if m.unknownFields != nil {
  4099  		i -= len(m.unknownFields)
  4100  		copy(dAtA[i:], m.unknownFields)
  4101  	}
  4102  	if m.DryRun {
  4103  		i--
  4104  		if m.DryRun {
  4105  			dAtA[i] = 1
  4106  		} else {
  4107  			dAtA[i] = 0
  4108  		}
  4109  		i--
  4110  		dAtA[i] = 0x18
  4111  	}
  4112  	if len(m.RestoreToPos) > 0 {
  4113  		i -= len(m.RestoreToPos)
  4114  		copy(dAtA[i:], m.RestoreToPos)
  4115  		i = encodeVarint(dAtA, i, uint64(len(m.RestoreToPos)))
  4116  		i--
  4117  		dAtA[i] = 0x12
  4118  	}
  4119  	if m.BackupTime != nil {
  4120  		size, err := m.BackupTime.MarshalToSizedBufferVT(dAtA[:i])
  4121  		if err != nil {
  4122  			return 0, err
  4123  		}
  4124  		i -= size
  4125  		i = encodeVarint(dAtA, i, uint64(size))
  4126  		i--
  4127  		dAtA[i] = 0xa
  4128  	}
  4129  	return len(dAtA) - i, nil
  4130  }
  4131  
  4132  func (m *RestoreFromBackupResponse) MarshalVT() (dAtA []byte, err error) {
  4133  	if m == nil {
  4134  		return nil, nil
  4135  	}
  4136  	size := m.SizeVT()
  4137  	dAtA = make([]byte, size)
  4138  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4139  	if err != nil {
  4140  		return nil, err
  4141  	}
  4142  	return dAtA[:n], nil
  4143  }
  4144  
  4145  func (m *RestoreFromBackupResponse) MarshalToVT(dAtA []byte) (int, error) {
  4146  	size := m.SizeVT()
  4147  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4148  }
  4149  
  4150  func (m *RestoreFromBackupResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4151  	if m == nil {
  4152  		return 0, nil
  4153  	}
  4154  	i := len(dAtA)
  4155  	_ = i
  4156  	var l int
  4157  	_ = l
  4158  	if m.unknownFields != nil {
  4159  		i -= len(m.unknownFields)
  4160  		copy(dAtA[i:], m.unknownFields)
  4161  	}
  4162  	if m.Event != nil {
  4163  		size, err := m.Event.MarshalToSizedBufferVT(dAtA[:i])
  4164  		if err != nil {
  4165  			return 0, err
  4166  		}
  4167  		i -= size
  4168  		i = encodeVarint(dAtA, i, uint64(size))
  4169  		i--
  4170  		dAtA[i] = 0xa
  4171  	}
  4172  	return len(dAtA) - i, nil
  4173  }
  4174  
  4175  func (m *VExecRequest) MarshalVT() (dAtA []byte, err error) {
  4176  	if m == nil {
  4177  		return nil, nil
  4178  	}
  4179  	size := m.SizeVT()
  4180  	dAtA = make([]byte, size)
  4181  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4182  	if err != nil {
  4183  		return nil, err
  4184  	}
  4185  	return dAtA[:n], nil
  4186  }
  4187  
  4188  func (m *VExecRequest) MarshalToVT(dAtA []byte) (int, error) {
  4189  	size := m.SizeVT()
  4190  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4191  }
  4192  
  4193  func (m *VExecRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4194  	if m == nil {
  4195  		return 0, nil
  4196  	}
  4197  	i := len(dAtA)
  4198  	_ = i
  4199  	var l int
  4200  	_ = l
  4201  	if m.unknownFields != nil {
  4202  		i -= len(m.unknownFields)
  4203  		copy(dAtA[i:], m.unknownFields)
  4204  	}
  4205  	if len(m.Keyspace) > 0 {
  4206  		i -= len(m.Keyspace)
  4207  		copy(dAtA[i:], m.Keyspace)
  4208  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  4209  		i--
  4210  		dAtA[i] = 0x1a
  4211  	}
  4212  	if len(m.Workflow) > 0 {
  4213  		i -= len(m.Workflow)
  4214  		copy(dAtA[i:], m.Workflow)
  4215  		i = encodeVarint(dAtA, i, uint64(len(m.Workflow)))
  4216  		i--
  4217  		dAtA[i] = 0x12
  4218  	}
  4219  	if len(m.Query) > 0 {
  4220  		i -= len(m.Query)
  4221  		copy(dAtA[i:], m.Query)
  4222  		i = encodeVarint(dAtA, i, uint64(len(m.Query)))
  4223  		i--
  4224  		dAtA[i] = 0xa
  4225  	}
  4226  	return len(dAtA) - i, nil
  4227  }
  4228  
  4229  func (m *VExecResponse) MarshalVT() (dAtA []byte, err error) {
  4230  	if m == nil {
  4231  		return nil, nil
  4232  	}
  4233  	size := m.SizeVT()
  4234  	dAtA = make([]byte, size)
  4235  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4236  	if err != nil {
  4237  		return nil, err
  4238  	}
  4239  	return dAtA[:n], nil
  4240  }
  4241  
  4242  func (m *VExecResponse) MarshalToVT(dAtA []byte) (int, error) {
  4243  	size := m.SizeVT()
  4244  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4245  }
  4246  
  4247  func (m *VExecResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4248  	if m == nil {
  4249  		return 0, nil
  4250  	}
  4251  	i := len(dAtA)
  4252  	_ = i
  4253  	var l int
  4254  	_ = l
  4255  	if m.unknownFields != nil {
  4256  		i -= len(m.unknownFields)
  4257  		copy(dAtA[i:], m.unknownFields)
  4258  	}
  4259  	if m.Result != nil {
  4260  		size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i])
  4261  		if err != nil {
  4262  			return 0, err
  4263  		}
  4264  		i -= size
  4265  		i = encodeVarint(dAtA, i, uint64(size))
  4266  		i--
  4267  		dAtA[i] = 0xa
  4268  	}
  4269  	return len(dAtA) - i, nil
  4270  }
  4271  
  4272  func (m *VDiffRequest) MarshalVT() (dAtA []byte, err error) {
  4273  	if m == nil {
  4274  		return nil, nil
  4275  	}
  4276  	size := m.SizeVT()
  4277  	dAtA = make([]byte, size)
  4278  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4279  	if err != nil {
  4280  		return nil, err
  4281  	}
  4282  	return dAtA[:n], nil
  4283  }
  4284  
  4285  func (m *VDiffRequest) MarshalToVT(dAtA []byte) (int, error) {
  4286  	size := m.SizeVT()
  4287  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4288  }
  4289  
  4290  func (m *VDiffRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4291  	if m == nil {
  4292  		return 0, nil
  4293  	}
  4294  	i := len(dAtA)
  4295  	_ = i
  4296  	var l int
  4297  	_ = l
  4298  	if m.unknownFields != nil {
  4299  		i -= len(m.unknownFields)
  4300  		copy(dAtA[i:], m.unknownFields)
  4301  	}
  4302  	if m.Options != nil {
  4303  		size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i])
  4304  		if err != nil {
  4305  			return 0, err
  4306  		}
  4307  		i -= size
  4308  		i = encodeVarint(dAtA, i, uint64(size))
  4309  		i--
  4310  		dAtA[i] = 0x32
  4311  	}
  4312  	if len(m.VdiffUuid) > 0 {
  4313  		i -= len(m.VdiffUuid)
  4314  		copy(dAtA[i:], m.VdiffUuid)
  4315  		i = encodeVarint(dAtA, i, uint64(len(m.VdiffUuid)))
  4316  		i--
  4317  		dAtA[i] = 0x2a
  4318  	}
  4319  	if len(m.ActionArg) > 0 {
  4320  		i -= len(m.ActionArg)
  4321  		copy(dAtA[i:], m.ActionArg)
  4322  		i = encodeVarint(dAtA, i, uint64(len(m.ActionArg)))
  4323  		i--
  4324  		dAtA[i] = 0x22
  4325  	}
  4326  	if len(m.Action) > 0 {
  4327  		i -= len(m.Action)
  4328  		copy(dAtA[i:], m.Action)
  4329  		i = encodeVarint(dAtA, i, uint64(len(m.Action)))
  4330  		i--
  4331  		dAtA[i] = 0x1a
  4332  	}
  4333  	if len(m.Workflow) > 0 {
  4334  		i -= len(m.Workflow)
  4335  		copy(dAtA[i:], m.Workflow)
  4336  		i = encodeVarint(dAtA, i, uint64(len(m.Workflow)))
  4337  		i--
  4338  		dAtA[i] = 0x12
  4339  	}
  4340  	if len(m.Keyspace) > 0 {
  4341  		i -= len(m.Keyspace)
  4342  		copy(dAtA[i:], m.Keyspace)
  4343  		i = encodeVarint(dAtA, i, uint64(len(m.Keyspace)))
  4344  		i--
  4345  		dAtA[i] = 0xa
  4346  	}
  4347  	return len(dAtA) - i, nil
  4348  }
  4349  
  4350  func (m *VDiffResponse) MarshalVT() (dAtA []byte, err error) {
  4351  	if m == nil {
  4352  		return nil, nil
  4353  	}
  4354  	size := m.SizeVT()
  4355  	dAtA = make([]byte, size)
  4356  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4357  	if err != nil {
  4358  		return nil, err
  4359  	}
  4360  	return dAtA[:n], nil
  4361  }
  4362  
  4363  func (m *VDiffResponse) MarshalToVT(dAtA []byte) (int, error) {
  4364  	size := m.SizeVT()
  4365  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4366  }
  4367  
  4368  func (m *VDiffResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4369  	if m == nil {
  4370  		return 0, nil
  4371  	}
  4372  	i := len(dAtA)
  4373  	_ = i
  4374  	var l int
  4375  	_ = l
  4376  	if m.unknownFields != nil {
  4377  		i -= len(m.unknownFields)
  4378  		copy(dAtA[i:], m.unknownFields)
  4379  	}
  4380  	if len(m.VdiffUuid) > 0 {
  4381  		i -= len(m.VdiffUuid)
  4382  		copy(dAtA[i:], m.VdiffUuid)
  4383  		i = encodeVarint(dAtA, i, uint64(len(m.VdiffUuid)))
  4384  		i--
  4385  		dAtA[i] = 0x1a
  4386  	}
  4387  	if m.Output != nil {
  4388  		size, err := m.Output.MarshalToSizedBufferVT(dAtA[:i])
  4389  		if err != nil {
  4390  			return 0, err
  4391  		}
  4392  		i -= size
  4393  		i = encodeVarint(dAtA, i, uint64(size))
  4394  		i--
  4395  		dAtA[i] = 0x12
  4396  	}
  4397  	if m.Id != 0 {
  4398  		i = encodeVarint(dAtA, i, uint64(m.Id))
  4399  		i--
  4400  		dAtA[i] = 0x8
  4401  	}
  4402  	return len(dAtA) - i, nil
  4403  }
  4404  
  4405  func (m *VDiffPickerOptions) MarshalVT() (dAtA []byte, err error) {
  4406  	if m == nil {
  4407  		return nil, nil
  4408  	}
  4409  	size := m.SizeVT()
  4410  	dAtA = make([]byte, size)
  4411  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4412  	if err != nil {
  4413  		return nil, err
  4414  	}
  4415  	return dAtA[:n], nil
  4416  }
  4417  
  4418  func (m *VDiffPickerOptions) MarshalToVT(dAtA []byte) (int, error) {
  4419  	size := m.SizeVT()
  4420  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4421  }
  4422  
  4423  func (m *VDiffPickerOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4424  	if m == nil {
  4425  		return 0, nil
  4426  	}
  4427  	i := len(dAtA)
  4428  	_ = i
  4429  	var l int
  4430  	_ = l
  4431  	if m.unknownFields != nil {
  4432  		i -= len(m.unknownFields)
  4433  		copy(dAtA[i:], m.unknownFields)
  4434  	}
  4435  	if len(m.TargetCell) > 0 {
  4436  		i -= len(m.TargetCell)
  4437  		copy(dAtA[i:], m.TargetCell)
  4438  		i = encodeVarint(dAtA, i, uint64(len(m.TargetCell)))
  4439  		i--
  4440  		dAtA[i] = 0x1a
  4441  	}
  4442  	if len(m.SourceCell) > 0 {
  4443  		i -= len(m.SourceCell)
  4444  		copy(dAtA[i:], m.SourceCell)
  4445  		i = encodeVarint(dAtA, i, uint64(len(m.SourceCell)))
  4446  		i--
  4447  		dAtA[i] = 0x12
  4448  	}
  4449  	if len(m.TabletTypes) > 0 {
  4450  		i -= len(m.TabletTypes)
  4451  		copy(dAtA[i:], m.TabletTypes)
  4452  		i = encodeVarint(dAtA, i, uint64(len(m.TabletTypes)))
  4453  		i--
  4454  		dAtA[i] = 0xa
  4455  	}
  4456  	return len(dAtA) - i, nil
  4457  }
  4458  
  4459  func (m *VDiffReportOptions) MarshalVT() (dAtA []byte, err error) {
  4460  	if m == nil {
  4461  		return nil, nil
  4462  	}
  4463  	size := m.SizeVT()
  4464  	dAtA = make([]byte, size)
  4465  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4466  	if err != nil {
  4467  		return nil, err
  4468  	}
  4469  	return dAtA[:n], nil
  4470  }
  4471  
  4472  func (m *VDiffReportOptions) MarshalToVT(dAtA []byte) (int, error) {
  4473  	size := m.SizeVT()
  4474  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4475  }
  4476  
  4477  func (m *VDiffReportOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4478  	if m == nil {
  4479  		return 0, nil
  4480  	}
  4481  	i := len(dAtA)
  4482  	_ = i
  4483  	var l int
  4484  	_ = l
  4485  	if m.unknownFields != nil {
  4486  		i -= len(m.unknownFields)
  4487  		copy(dAtA[i:], m.unknownFields)
  4488  	}
  4489  	if len(m.Format) > 0 {
  4490  		i -= len(m.Format)
  4491  		copy(dAtA[i:], m.Format)
  4492  		i = encodeVarint(dAtA, i, uint64(len(m.Format)))
  4493  		i--
  4494  		dAtA[i] = 0x1a
  4495  	}
  4496  	if m.DebugQuery {
  4497  		i--
  4498  		if m.DebugQuery {
  4499  			dAtA[i] = 1
  4500  		} else {
  4501  			dAtA[i] = 0
  4502  		}
  4503  		i--
  4504  		dAtA[i] = 0x10
  4505  	}
  4506  	if m.OnlyPks {
  4507  		i--
  4508  		if m.OnlyPks {
  4509  			dAtA[i] = 1
  4510  		} else {
  4511  			dAtA[i] = 0
  4512  		}
  4513  		i--
  4514  		dAtA[i] = 0x8
  4515  	}
  4516  	return len(dAtA) - i, nil
  4517  }
  4518  
  4519  func (m *VDiffCoreOptions) MarshalVT() (dAtA []byte, err error) {
  4520  	if m == nil {
  4521  		return nil, nil
  4522  	}
  4523  	size := m.SizeVT()
  4524  	dAtA = make([]byte, size)
  4525  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4526  	if err != nil {
  4527  		return nil, err
  4528  	}
  4529  	return dAtA[:n], nil
  4530  }
  4531  
  4532  func (m *VDiffCoreOptions) MarshalToVT(dAtA []byte) (int, error) {
  4533  	size := m.SizeVT()
  4534  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4535  }
  4536  
  4537  func (m *VDiffCoreOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4538  	if m == nil {
  4539  		return 0, nil
  4540  	}
  4541  	i := len(dAtA)
  4542  	_ = i
  4543  	var l int
  4544  	_ = l
  4545  	if m.unknownFields != nil {
  4546  		i -= len(m.unknownFields)
  4547  		copy(dAtA[i:], m.unknownFields)
  4548  	}
  4549  	if m.MaxExtraRowsToCompare != 0 {
  4550  		i = encodeVarint(dAtA, i, uint64(m.MaxExtraRowsToCompare))
  4551  		i--
  4552  		dAtA[i] = 0x38
  4553  	}
  4554  	if m.TimeoutSeconds != 0 {
  4555  		i = encodeVarint(dAtA, i, uint64(m.TimeoutSeconds))
  4556  		i--
  4557  		dAtA[i] = 0x30
  4558  	}
  4559  	if m.SamplePct != 0 {
  4560  		i = encodeVarint(dAtA, i, uint64(m.SamplePct))
  4561  		i--
  4562  		dAtA[i] = 0x28
  4563  	}
  4564  	if m.Checksum {
  4565  		i--
  4566  		if m.Checksum {
  4567  			dAtA[i] = 1
  4568  		} else {
  4569  			dAtA[i] = 0
  4570  		}
  4571  		i--
  4572  		dAtA[i] = 0x20
  4573  	}
  4574  	if m.MaxRows != 0 {
  4575  		i = encodeVarint(dAtA, i, uint64(m.MaxRows))
  4576  		i--
  4577  		dAtA[i] = 0x18
  4578  	}
  4579  	if m.AutoRetry {
  4580  		i--
  4581  		if m.AutoRetry {
  4582  			dAtA[i] = 1
  4583  		} else {
  4584  			dAtA[i] = 0
  4585  		}
  4586  		i--
  4587  		dAtA[i] = 0x10
  4588  	}
  4589  	if len(m.Tables) > 0 {
  4590  		i -= len(m.Tables)
  4591  		copy(dAtA[i:], m.Tables)
  4592  		i = encodeVarint(dAtA, i, uint64(len(m.Tables)))
  4593  		i--
  4594  		dAtA[i] = 0xa
  4595  	}
  4596  	return len(dAtA) - i, nil
  4597  }
  4598  
  4599  func (m *VDiffOptions) MarshalVT() (dAtA []byte, err error) {
  4600  	if m == nil {
  4601  		return nil, nil
  4602  	}
  4603  	size := m.SizeVT()
  4604  	dAtA = make([]byte, size)
  4605  	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
  4606  	if err != nil {
  4607  		return nil, err
  4608  	}
  4609  	return dAtA[:n], nil
  4610  }
  4611  
  4612  func (m *VDiffOptions) MarshalToVT(dAtA []byte) (int, error) {
  4613  	size := m.SizeVT()
  4614  	return m.MarshalToSizedBufferVT(dAtA[:size])
  4615  }
  4616  
  4617  func (m *VDiffOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
  4618  	if m == nil {
  4619  		return 0, nil
  4620  	}
  4621  	i := len(dAtA)
  4622  	_ = i
  4623  	var l int
  4624  	_ = l
  4625  	if m.unknownFields != nil {
  4626  		i -= len(m.unknownFields)
  4627  		copy(dAtA[i:], m.unknownFields)
  4628  	}
  4629  	if m.ReportOptions != nil {
  4630  		size, err := m.ReportOptions.MarshalToSizedBufferVT(dAtA[:i])
  4631  		if err != nil {
  4632  			return 0, err
  4633  		}
  4634  		i -= size
  4635  		i = encodeVarint(dAtA, i, uint64(size))
  4636  		i--
  4637  		dAtA[i] = 0x1a
  4638  	}
  4639  	if m.CoreOptions != nil {
  4640  		size, err := m.CoreOptions.MarshalToSizedBufferVT(dAtA[:i])
  4641  		if err != nil {
  4642  			return 0, err
  4643  		}
  4644  		i -= size
  4645  		i = encodeVarint(dAtA, i, uint64(size))
  4646  		i--
  4647  		dAtA[i] = 0x12
  4648  	}
  4649  	if m.PickerOptions != nil {
  4650  		size, err := m.PickerOptions.MarshalToSizedBufferVT(dAtA[:i])
  4651  		if err != nil {
  4652  			return 0, err
  4653  		}
  4654  		i -= size
  4655  		i = encodeVarint(dAtA, i, uint64(size))
  4656  		i--
  4657  		dAtA[i] = 0xa
  4658  	}
  4659  	return len(dAtA) - i, nil
  4660  }
  4661  
  4662  func encodeVarint(dAtA []byte, offset int, v uint64) int {
  4663  	offset -= sov(v)
  4664  	base := offset
  4665  	for v >= 1<<7 {
  4666  		dAtA[offset] = uint8(v&0x7f | 0x80)
  4667  		v >>= 7
  4668  		offset++
  4669  	}
  4670  	dAtA[offset] = uint8(v)
  4671  	return base
  4672  }
  4673  func (m *TableDefinition) SizeVT() (n int) {
  4674  	if m == nil {
  4675  		return 0
  4676  	}
  4677  	var l int
  4678  	_ = l
  4679  	l = len(m.Name)
  4680  	if l > 0 {
  4681  		n += 1 + l + sov(uint64(l))
  4682  	}
  4683  	l = len(m.Schema)
  4684  	if l > 0 {
  4685  		n += 1 + l + sov(uint64(l))
  4686  	}
  4687  	if len(m.Columns) > 0 {
  4688  		for _, s := range m.Columns {
  4689  			l = len(s)
  4690  			n += 1 + l + sov(uint64(l))
  4691  		}
  4692  	}
  4693  	if len(m.PrimaryKeyColumns) > 0 {
  4694  		for _, s := range m.PrimaryKeyColumns {
  4695  			l = len(s)
  4696  			n += 1 + l + sov(uint64(l))
  4697  		}
  4698  	}
  4699  	l = len(m.Type)
  4700  	if l > 0 {
  4701  		n += 1 + l + sov(uint64(l))
  4702  	}
  4703  	if m.DataLength != 0 {
  4704  		n += 1 + sov(uint64(m.DataLength))
  4705  	}
  4706  	if m.RowCount != 0 {
  4707  		n += 1 + sov(uint64(m.RowCount))
  4708  	}
  4709  	if len(m.Fields) > 0 {
  4710  		for _, e := range m.Fields {
  4711  			l = e.SizeVT()
  4712  			n += 1 + l + sov(uint64(l))
  4713  		}
  4714  	}
  4715  	n += len(m.unknownFields)
  4716  	return n
  4717  }
  4718  
  4719  func (m *SchemaDefinition) SizeVT() (n int) {
  4720  	if m == nil {
  4721  		return 0
  4722  	}
  4723  	var l int
  4724  	_ = l
  4725  	l = len(m.DatabaseSchema)
  4726  	if l > 0 {
  4727  		n += 1 + l + sov(uint64(l))
  4728  	}
  4729  	if len(m.TableDefinitions) > 0 {
  4730  		for _, e := range m.TableDefinitions {
  4731  			l = e.SizeVT()
  4732  			n += 1 + l + sov(uint64(l))
  4733  		}
  4734  	}
  4735  	l = len(m.Version)
  4736  	if l > 0 {
  4737  		n += 1 + l + sov(uint64(l))
  4738  	}
  4739  	n += len(m.unknownFields)
  4740  	return n
  4741  }
  4742  
  4743  func (m *SchemaChangeResult) SizeVT() (n int) {
  4744  	if m == nil {
  4745  		return 0
  4746  	}
  4747  	var l int
  4748  	_ = l
  4749  	if m.BeforeSchema != nil {
  4750  		l = m.BeforeSchema.SizeVT()
  4751  		n += 1 + l + sov(uint64(l))
  4752  	}
  4753  	if m.AfterSchema != nil {
  4754  		l = m.AfterSchema.SizeVT()
  4755  		n += 1 + l + sov(uint64(l))
  4756  	}
  4757  	n += len(m.unknownFields)
  4758  	return n
  4759  }
  4760  
  4761  func (m *UserPermission) SizeVT() (n int) {
  4762  	if m == nil {
  4763  		return 0
  4764  	}
  4765  	var l int
  4766  	_ = l
  4767  	l = len(m.Host)
  4768  	if l > 0 {
  4769  		n += 1 + l + sov(uint64(l))
  4770  	}
  4771  	l = len(m.User)
  4772  	if l > 0 {
  4773  		n += 1 + l + sov(uint64(l))
  4774  	}
  4775  	if m.PasswordChecksum != 0 {
  4776  		n += 1 + sov(uint64(m.PasswordChecksum))
  4777  	}
  4778  	if len(m.Privileges) > 0 {
  4779  		for k, v := range m.Privileges {
  4780  			_ = k
  4781  			_ = v
  4782  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + 1 + len(v) + sov(uint64(len(v)))
  4783  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  4784  		}
  4785  	}
  4786  	n += len(m.unknownFields)
  4787  	return n
  4788  }
  4789  
  4790  func (m *DbPermission) SizeVT() (n int) {
  4791  	if m == nil {
  4792  		return 0
  4793  	}
  4794  	var l int
  4795  	_ = l
  4796  	l = len(m.Host)
  4797  	if l > 0 {
  4798  		n += 1 + l + sov(uint64(l))
  4799  	}
  4800  	l = len(m.Db)
  4801  	if l > 0 {
  4802  		n += 1 + l + sov(uint64(l))
  4803  	}
  4804  	l = len(m.User)
  4805  	if l > 0 {
  4806  		n += 1 + l + sov(uint64(l))
  4807  	}
  4808  	if len(m.Privileges) > 0 {
  4809  		for k, v := range m.Privileges {
  4810  			_ = k
  4811  			_ = v
  4812  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + 1 + len(v) + sov(uint64(len(v)))
  4813  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  4814  		}
  4815  	}
  4816  	n += len(m.unknownFields)
  4817  	return n
  4818  }
  4819  
  4820  func (m *Permissions) SizeVT() (n int) {
  4821  	if m == nil {
  4822  		return 0
  4823  	}
  4824  	var l int
  4825  	_ = l
  4826  	if len(m.UserPermissions) > 0 {
  4827  		for _, e := range m.UserPermissions {
  4828  			l = e.SizeVT()
  4829  			n += 1 + l + sov(uint64(l))
  4830  		}
  4831  	}
  4832  	if len(m.DbPermissions) > 0 {
  4833  		for _, e := range m.DbPermissions {
  4834  			l = e.SizeVT()
  4835  			n += 1 + l + sov(uint64(l))
  4836  		}
  4837  	}
  4838  	n += len(m.unknownFields)
  4839  	return n
  4840  }
  4841  
  4842  func (m *PingRequest) SizeVT() (n int) {
  4843  	if m == nil {
  4844  		return 0
  4845  	}
  4846  	var l int
  4847  	_ = l
  4848  	l = len(m.Payload)
  4849  	if l > 0 {
  4850  		n += 1 + l + sov(uint64(l))
  4851  	}
  4852  	n += len(m.unknownFields)
  4853  	return n
  4854  }
  4855  
  4856  func (m *PingResponse) SizeVT() (n int) {
  4857  	if m == nil {
  4858  		return 0
  4859  	}
  4860  	var l int
  4861  	_ = l
  4862  	l = len(m.Payload)
  4863  	if l > 0 {
  4864  		n += 1 + l + sov(uint64(l))
  4865  	}
  4866  	n += len(m.unknownFields)
  4867  	return n
  4868  }
  4869  
  4870  func (m *SleepRequest) SizeVT() (n int) {
  4871  	if m == nil {
  4872  		return 0
  4873  	}
  4874  	var l int
  4875  	_ = l
  4876  	if m.Duration != 0 {
  4877  		n += 1 + sov(uint64(m.Duration))
  4878  	}
  4879  	n += len(m.unknownFields)
  4880  	return n
  4881  }
  4882  
  4883  func (m *SleepResponse) SizeVT() (n int) {
  4884  	if m == nil {
  4885  		return 0
  4886  	}
  4887  	var l int
  4888  	_ = l
  4889  	n += len(m.unknownFields)
  4890  	return n
  4891  }
  4892  
  4893  func (m *ExecuteHookRequest) SizeVT() (n int) {
  4894  	if m == nil {
  4895  		return 0
  4896  	}
  4897  	var l int
  4898  	_ = l
  4899  	l = len(m.Name)
  4900  	if l > 0 {
  4901  		n += 1 + l + sov(uint64(l))
  4902  	}
  4903  	if len(m.Parameters) > 0 {
  4904  		for _, s := range m.Parameters {
  4905  			l = len(s)
  4906  			n += 1 + l + sov(uint64(l))
  4907  		}
  4908  	}
  4909  	if len(m.ExtraEnv) > 0 {
  4910  		for k, v := range m.ExtraEnv {
  4911  			_ = k
  4912  			_ = v
  4913  			mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + 1 + len(v) + sov(uint64(len(v)))
  4914  			n += mapEntrySize + 1 + sov(uint64(mapEntrySize))
  4915  		}
  4916  	}
  4917  	n += len(m.unknownFields)
  4918  	return n
  4919  }
  4920  
  4921  func (m *ExecuteHookResponse) SizeVT() (n int) {
  4922  	if m == nil {
  4923  		return 0
  4924  	}
  4925  	var l int
  4926  	_ = l
  4927  	if m.ExitStatus != 0 {
  4928  		n += 1 + sov(uint64(m.ExitStatus))
  4929  	}
  4930  	l = len(m.Stdout)
  4931  	if l > 0 {
  4932  		n += 1 + l + sov(uint64(l))
  4933  	}
  4934  	l = len(m.Stderr)
  4935  	if l > 0 {
  4936  		n += 1 + l + sov(uint64(l))
  4937  	}
  4938  	n += len(m.unknownFields)
  4939  	return n
  4940  }
  4941  
  4942  func (m *GetSchemaRequest) SizeVT() (n int) {
  4943  	if m == nil {
  4944  		return 0
  4945  	}
  4946  	var l int
  4947  	_ = l
  4948  	if len(m.Tables) > 0 {
  4949  		for _, s := range m.Tables {
  4950  			l = len(s)
  4951  			n += 1 + l + sov(uint64(l))
  4952  		}
  4953  	}
  4954  	if m.IncludeViews {
  4955  		n += 2
  4956  	}
  4957  	if len(m.ExcludeTables) > 0 {
  4958  		for _, s := range m.ExcludeTables {
  4959  			l = len(s)
  4960  			n += 1 + l + sov(uint64(l))
  4961  		}
  4962  	}
  4963  	if m.TableSchemaOnly {
  4964  		n += 2
  4965  	}
  4966  	n += len(m.unknownFields)
  4967  	return n
  4968  }
  4969  
  4970  func (m *GetSchemaResponse) SizeVT() (n int) {
  4971  	if m == nil {
  4972  		return 0
  4973  	}
  4974  	var l int
  4975  	_ = l
  4976  	if m.SchemaDefinition != nil {
  4977  		l = m.SchemaDefinition.SizeVT()
  4978  		n += 1 + l + sov(uint64(l))
  4979  	}
  4980  	n += len(m.unknownFields)
  4981  	return n
  4982  }
  4983  
  4984  func (m *GetPermissionsRequest) SizeVT() (n int) {
  4985  	if m == nil {
  4986  		return 0
  4987  	}
  4988  	var l int
  4989  	_ = l
  4990  	n += len(m.unknownFields)
  4991  	return n
  4992  }
  4993  
  4994  func (m *GetPermissionsResponse) SizeVT() (n int) {
  4995  	if m == nil {
  4996  		return 0
  4997  	}
  4998  	var l int
  4999  	_ = l
  5000  	if m.Permissions != nil {
  5001  		l = m.Permissions.SizeVT()
  5002  		n += 1 + l + sov(uint64(l))
  5003  	}
  5004  	n += len(m.unknownFields)
  5005  	return n
  5006  }
  5007  
  5008  func (m *SetReadOnlyRequest) SizeVT() (n int) {
  5009  	if m == nil {
  5010  		return 0
  5011  	}
  5012  	var l int
  5013  	_ = l
  5014  	n += len(m.unknownFields)
  5015  	return n
  5016  }
  5017  
  5018  func (m *SetReadOnlyResponse) SizeVT() (n int) {
  5019  	if m == nil {
  5020  		return 0
  5021  	}
  5022  	var l int
  5023  	_ = l
  5024  	n += len(m.unknownFields)
  5025  	return n
  5026  }
  5027  
  5028  func (m *SetReadWriteRequest) SizeVT() (n int) {
  5029  	if m == nil {
  5030  		return 0
  5031  	}
  5032  	var l int
  5033  	_ = l
  5034  	n += len(m.unknownFields)
  5035  	return n
  5036  }
  5037  
  5038  func (m *SetReadWriteResponse) SizeVT() (n int) {
  5039  	if m == nil {
  5040  		return 0
  5041  	}
  5042  	var l int
  5043  	_ = l
  5044  	n += len(m.unknownFields)
  5045  	return n
  5046  }
  5047  
  5048  func (m *ChangeTypeRequest) SizeVT() (n int) {
  5049  	if m == nil {
  5050  		return 0
  5051  	}
  5052  	var l int
  5053  	_ = l
  5054  	if m.TabletType != 0 {
  5055  		n += 1 + sov(uint64(m.TabletType))
  5056  	}
  5057  	if m.SemiSync {
  5058  		n += 2
  5059  	}
  5060  	n += len(m.unknownFields)
  5061  	return n
  5062  }
  5063  
  5064  func (m *ChangeTypeResponse) SizeVT() (n int) {
  5065  	if m == nil {
  5066  		return 0
  5067  	}
  5068  	var l int
  5069  	_ = l
  5070  	n += len(m.unknownFields)
  5071  	return n
  5072  }
  5073  
  5074  func (m *RefreshStateRequest) SizeVT() (n int) {
  5075  	if m == nil {
  5076  		return 0
  5077  	}
  5078  	var l int
  5079  	_ = l
  5080  	n += len(m.unknownFields)
  5081  	return n
  5082  }
  5083  
  5084  func (m *RefreshStateResponse) SizeVT() (n int) {
  5085  	if m == nil {
  5086  		return 0
  5087  	}
  5088  	var l int
  5089  	_ = l
  5090  	n += len(m.unknownFields)
  5091  	return n
  5092  }
  5093  
  5094  func (m *RunHealthCheckRequest) SizeVT() (n int) {
  5095  	if m == nil {
  5096  		return 0
  5097  	}
  5098  	var l int
  5099  	_ = l
  5100  	n += len(m.unknownFields)
  5101  	return n
  5102  }
  5103  
  5104  func (m *RunHealthCheckResponse) SizeVT() (n int) {
  5105  	if m == nil {
  5106  		return 0
  5107  	}
  5108  	var l int
  5109  	_ = l
  5110  	n += len(m.unknownFields)
  5111  	return n
  5112  }
  5113  
  5114  func (m *ReloadSchemaRequest) SizeVT() (n int) {
  5115  	if m == nil {
  5116  		return 0
  5117  	}
  5118  	var l int
  5119  	_ = l
  5120  	l = len(m.WaitPosition)
  5121  	if l > 0 {
  5122  		n += 1 + l + sov(uint64(l))
  5123  	}
  5124  	n += len(m.unknownFields)
  5125  	return n
  5126  }
  5127  
  5128  func (m *ReloadSchemaResponse) SizeVT() (n int) {
  5129  	if m == nil {
  5130  		return 0
  5131  	}
  5132  	var l int
  5133  	_ = l
  5134  	n += len(m.unknownFields)
  5135  	return n
  5136  }
  5137  
  5138  func (m *PreflightSchemaRequest) SizeVT() (n int) {
  5139  	if m == nil {
  5140  		return 0
  5141  	}
  5142  	var l int
  5143  	_ = l
  5144  	if len(m.Changes) > 0 {
  5145  		for _, s := range m.Changes {
  5146  			l = len(s)
  5147  			n += 1 + l + sov(uint64(l))
  5148  		}
  5149  	}
  5150  	n += len(m.unknownFields)
  5151  	return n
  5152  }
  5153  
  5154  func (m *PreflightSchemaResponse) SizeVT() (n int) {
  5155  	if m == nil {
  5156  		return 0
  5157  	}
  5158  	var l int
  5159  	_ = l
  5160  	if len(m.ChangeResults) > 0 {
  5161  		for _, e := range m.ChangeResults {
  5162  			l = e.SizeVT()
  5163  			n += 1 + l + sov(uint64(l))
  5164  		}
  5165  	}
  5166  	n += len(m.unknownFields)
  5167  	return n
  5168  }
  5169  
  5170  func (m *ApplySchemaRequest) SizeVT() (n int) {
  5171  	if m == nil {
  5172  		return 0
  5173  	}
  5174  	var l int
  5175  	_ = l
  5176  	l = len(m.Sql)
  5177  	if l > 0 {
  5178  		n += 1 + l + sov(uint64(l))
  5179  	}
  5180  	if m.Force {
  5181  		n += 2
  5182  	}
  5183  	if m.AllowReplication {
  5184  		n += 2
  5185  	}
  5186  	if m.BeforeSchema != nil {
  5187  		l = m.BeforeSchema.SizeVT()
  5188  		n += 1 + l + sov(uint64(l))
  5189  	}
  5190  	if m.AfterSchema != nil {
  5191  		l = m.AfterSchema.SizeVT()
  5192  		n += 1 + l + sov(uint64(l))
  5193  	}
  5194  	l = len(m.SqlMode)
  5195  	if l > 0 {
  5196  		n += 1 + l + sov(uint64(l))
  5197  	}
  5198  	n += len(m.unknownFields)
  5199  	return n
  5200  }
  5201  
  5202  func (m *ApplySchemaResponse) SizeVT() (n int) {
  5203  	if m == nil {
  5204  		return 0
  5205  	}
  5206  	var l int
  5207  	_ = l
  5208  	if m.BeforeSchema != nil {
  5209  		l = m.BeforeSchema.SizeVT()
  5210  		n += 1 + l + sov(uint64(l))
  5211  	}
  5212  	if m.AfterSchema != nil {
  5213  		l = m.AfterSchema.SizeVT()
  5214  		n += 1 + l + sov(uint64(l))
  5215  	}
  5216  	n += len(m.unknownFields)
  5217  	return n
  5218  }
  5219  
  5220  func (m *LockTablesRequest) SizeVT() (n int) {
  5221  	if m == nil {
  5222  		return 0
  5223  	}
  5224  	var l int
  5225  	_ = l
  5226  	n += len(m.unknownFields)
  5227  	return n
  5228  }
  5229  
  5230  func (m *LockTablesResponse) SizeVT() (n int) {
  5231  	if m == nil {
  5232  		return 0
  5233  	}
  5234  	var l int
  5235  	_ = l
  5236  	n += len(m.unknownFields)
  5237  	return n
  5238  }
  5239  
  5240  func (m *UnlockTablesRequest) SizeVT() (n int) {
  5241  	if m == nil {
  5242  		return 0
  5243  	}
  5244  	var l int
  5245  	_ = l
  5246  	n += len(m.unknownFields)
  5247  	return n
  5248  }
  5249  
  5250  func (m *UnlockTablesResponse) SizeVT() (n int) {
  5251  	if m == nil {
  5252  		return 0
  5253  	}
  5254  	var l int
  5255  	_ = l
  5256  	n += len(m.unknownFields)
  5257  	return n
  5258  }
  5259  
  5260  func (m *ExecuteQueryRequest) SizeVT() (n int) {
  5261  	if m == nil {
  5262  		return 0
  5263  	}
  5264  	var l int
  5265  	_ = l
  5266  	l = len(m.Query)
  5267  	if l > 0 {
  5268  		n += 1 + l + sov(uint64(l))
  5269  	}
  5270  	l = len(m.DbName)
  5271  	if l > 0 {
  5272  		n += 1 + l + sov(uint64(l))
  5273  	}
  5274  	if m.MaxRows != 0 {
  5275  		n += 1 + sov(uint64(m.MaxRows))
  5276  	}
  5277  	if m.CallerId != nil {
  5278  		l = m.CallerId.SizeVT()
  5279  		n += 1 + l + sov(uint64(l))
  5280  	}
  5281  	n += len(m.unknownFields)
  5282  	return n
  5283  }
  5284  
  5285  func (m *ExecuteQueryResponse) SizeVT() (n int) {
  5286  	if m == nil {
  5287  		return 0
  5288  	}
  5289  	var l int
  5290  	_ = l
  5291  	if m.Result != nil {
  5292  		l = m.Result.SizeVT()
  5293  		n += 1 + l + sov(uint64(l))
  5294  	}
  5295  	n += len(m.unknownFields)
  5296  	return n
  5297  }
  5298  
  5299  func (m *ExecuteFetchAsDbaRequest) SizeVT() (n int) {
  5300  	if m == nil {
  5301  		return 0
  5302  	}
  5303  	var l int
  5304  	_ = l
  5305  	l = len(m.Query)
  5306  	if l > 0 {
  5307  		n += 1 + l + sov(uint64(l))
  5308  	}
  5309  	l = len(m.DbName)
  5310  	if l > 0 {
  5311  		n += 1 + l + sov(uint64(l))
  5312  	}
  5313  	if m.MaxRows != 0 {
  5314  		n += 1 + sov(uint64(m.MaxRows))
  5315  	}
  5316  	if m.DisableBinlogs {
  5317  		n += 2
  5318  	}
  5319  	if m.ReloadSchema {
  5320  		n += 2
  5321  	}
  5322  	n += len(m.unknownFields)
  5323  	return n
  5324  }
  5325  
  5326  func (m *ExecuteFetchAsDbaResponse) SizeVT() (n int) {
  5327  	if m == nil {
  5328  		return 0
  5329  	}
  5330  	var l int
  5331  	_ = l
  5332  	if m.Result != nil {
  5333  		l = m.Result.SizeVT()
  5334  		n += 1 + l + sov(uint64(l))
  5335  	}
  5336  	n += len(m.unknownFields)
  5337  	return n
  5338  }
  5339  
  5340  func (m *ExecuteFetchAsAllPrivsRequest) SizeVT() (n int) {
  5341  	if m == nil {
  5342  		return 0
  5343  	}
  5344  	var l int
  5345  	_ = l
  5346  	l = len(m.Query)
  5347  	if l > 0 {
  5348  		n += 1 + l + sov(uint64(l))
  5349  	}
  5350  	l = len(m.DbName)
  5351  	if l > 0 {
  5352  		n += 1 + l + sov(uint64(l))
  5353  	}
  5354  	if m.MaxRows != 0 {
  5355  		n += 1 + sov(uint64(m.MaxRows))
  5356  	}
  5357  	if m.ReloadSchema {
  5358  		n += 2
  5359  	}
  5360  	n += len(m.unknownFields)
  5361  	return n
  5362  }
  5363  
  5364  func (m *ExecuteFetchAsAllPrivsResponse) SizeVT() (n int) {
  5365  	if m == nil {
  5366  		return 0
  5367  	}
  5368  	var l int
  5369  	_ = l
  5370  	if m.Result != nil {
  5371  		l = m.Result.SizeVT()
  5372  		n += 1 + l + sov(uint64(l))
  5373  	}
  5374  	n += len(m.unknownFields)
  5375  	return n
  5376  }
  5377  
  5378  func (m *ExecuteFetchAsAppRequest) SizeVT() (n int) {
  5379  	if m == nil {
  5380  		return 0
  5381  	}
  5382  	var l int
  5383  	_ = l
  5384  	l = len(m.Query)
  5385  	if l > 0 {
  5386  		n += 1 + l + sov(uint64(l))
  5387  	}
  5388  	if m.MaxRows != 0 {
  5389  		n += 1 + sov(uint64(m.MaxRows))
  5390  	}
  5391  	n += len(m.unknownFields)
  5392  	return n
  5393  }
  5394  
  5395  func (m *ExecuteFetchAsAppResponse) SizeVT() (n int) {
  5396  	if m == nil {
  5397  		return 0
  5398  	}
  5399  	var l int
  5400  	_ = l
  5401  	if m.Result != nil {
  5402  		l = m.Result.SizeVT()
  5403  		n += 1 + l + sov(uint64(l))
  5404  	}
  5405  	n += len(m.unknownFields)
  5406  	return n
  5407  }
  5408  
  5409  func (m *ReplicationStatusRequest) SizeVT() (n int) {
  5410  	if m == nil {
  5411  		return 0
  5412  	}
  5413  	var l int
  5414  	_ = l
  5415  	n += len(m.unknownFields)
  5416  	return n
  5417  }
  5418  
  5419  func (m *ReplicationStatusResponse) SizeVT() (n int) {
  5420  	if m == nil {
  5421  		return 0
  5422  	}
  5423  	var l int
  5424  	_ = l
  5425  	if m.Status != nil {
  5426  		l = m.Status.SizeVT()
  5427  		n += 1 + l + sov(uint64(l))
  5428  	}
  5429  	n += len(m.unknownFields)
  5430  	return n
  5431  }
  5432  
  5433  func (m *PrimaryStatusRequest) SizeVT() (n int) {
  5434  	if m == nil {
  5435  		return 0
  5436  	}
  5437  	var l int
  5438  	_ = l
  5439  	n += len(m.unknownFields)
  5440  	return n
  5441  }
  5442  
  5443  func (m *PrimaryStatusResponse) SizeVT() (n int) {
  5444  	if m == nil {
  5445  		return 0
  5446  	}
  5447  	var l int
  5448  	_ = l
  5449  	if m.Status != nil {
  5450  		l = m.Status.SizeVT()
  5451  		n += 1 + l + sov(uint64(l))
  5452  	}
  5453  	n += len(m.unknownFields)
  5454  	return n
  5455  }
  5456  
  5457  func (m *PrimaryPositionRequest) SizeVT() (n int) {
  5458  	if m == nil {
  5459  		return 0
  5460  	}
  5461  	var l int
  5462  	_ = l
  5463  	n += len(m.unknownFields)
  5464  	return n
  5465  }
  5466  
  5467  func (m *PrimaryPositionResponse) SizeVT() (n int) {
  5468  	if m == nil {
  5469  		return 0
  5470  	}
  5471  	var l int
  5472  	_ = l
  5473  	l = len(m.Position)
  5474  	if l > 0 {
  5475  		n += 1 + l + sov(uint64(l))
  5476  	}
  5477  	n += len(m.unknownFields)
  5478  	return n
  5479  }
  5480  
  5481  func (m *WaitForPositionRequest) SizeVT() (n int) {
  5482  	if m == nil {
  5483  		return 0
  5484  	}
  5485  	var l int
  5486  	_ = l
  5487  	l = len(m.Position)
  5488  	if l > 0 {
  5489  		n += 1 + l + sov(uint64(l))
  5490  	}
  5491  	n += len(m.unknownFields)
  5492  	return n
  5493  }
  5494  
  5495  func (m *WaitForPositionResponse) SizeVT() (n int) {
  5496  	if m == nil {
  5497  		return 0
  5498  	}
  5499  	var l int
  5500  	_ = l
  5501  	n += len(m.unknownFields)
  5502  	return n
  5503  }
  5504  
  5505  func (m *StopReplicationRequest) SizeVT() (n int) {
  5506  	if m == nil {
  5507  		return 0
  5508  	}
  5509  	var l int
  5510  	_ = l
  5511  	n += len(m.unknownFields)
  5512  	return n
  5513  }
  5514  
  5515  func (m *StopReplicationResponse) SizeVT() (n int) {
  5516  	if m == nil {
  5517  		return 0
  5518  	}
  5519  	var l int
  5520  	_ = l
  5521  	n += len(m.unknownFields)
  5522  	return n
  5523  }
  5524  
  5525  func (m *StopReplicationMinimumRequest) SizeVT() (n int) {
  5526  	if m == nil {
  5527  		return 0
  5528  	}
  5529  	var l int
  5530  	_ = l
  5531  	l = len(m.Position)
  5532  	if l > 0 {
  5533  		n += 1 + l + sov(uint64(l))
  5534  	}
  5535  	if m.WaitTimeout != 0 {
  5536  		n += 1 + sov(uint64(m.WaitTimeout))
  5537  	}
  5538  	n += len(m.unknownFields)
  5539  	return n
  5540  }
  5541  
  5542  func (m *StopReplicationMinimumResponse) SizeVT() (n int) {
  5543  	if m == nil {
  5544  		return 0
  5545  	}
  5546  	var l int
  5547  	_ = l
  5548  	l = len(m.Position)
  5549  	if l > 0 {
  5550  		n += 1 + l + sov(uint64(l))
  5551  	}
  5552  	n += len(m.unknownFields)
  5553  	return n
  5554  }
  5555  
  5556  func (m *StartReplicationRequest) SizeVT() (n int) {
  5557  	if m == nil {
  5558  		return 0
  5559  	}
  5560  	var l int
  5561  	_ = l
  5562  	if m.SemiSync {
  5563  		n += 2
  5564  	}
  5565  	n += len(m.unknownFields)
  5566  	return n
  5567  }
  5568  
  5569  func (m *StartReplicationResponse) SizeVT() (n int) {
  5570  	if m == nil {
  5571  		return 0
  5572  	}
  5573  	var l int
  5574  	_ = l
  5575  	n += len(m.unknownFields)
  5576  	return n
  5577  }
  5578  
  5579  func (m *StartReplicationUntilAfterRequest) SizeVT() (n int) {
  5580  	if m == nil {
  5581  		return 0
  5582  	}
  5583  	var l int
  5584  	_ = l
  5585  	l = len(m.Position)
  5586  	if l > 0 {
  5587  		n += 1 + l + sov(uint64(l))
  5588  	}
  5589  	if m.WaitTimeout != 0 {
  5590  		n += 1 + sov(uint64(m.WaitTimeout))
  5591  	}
  5592  	n += len(m.unknownFields)
  5593  	return n
  5594  }
  5595  
  5596  func (m *StartReplicationUntilAfterResponse) SizeVT() (n int) {
  5597  	if m == nil {
  5598  		return 0
  5599  	}
  5600  	var l int
  5601  	_ = l
  5602  	n += len(m.unknownFields)
  5603  	return n
  5604  }
  5605  
  5606  func (m *GetReplicasRequest) SizeVT() (n int) {
  5607  	if m == nil {
  5608  		return 0
  5609  	}
  5610  	var l int
  5611  	_ = l
  5612  	n += len(m.unknownFields)
  5613  	return n
  5614  }
  5615  
  5616  func (m *GetReplicasResponse) SizeVT() (n int) {
  5617  	if m == nil {
  5618  		return 0
  5619  	}
  5620  	var l int
  5621  	_ = l
  5622  	if len(m.Addrs) > 0 {
  5623  		for _, s := range m.Addrs {
  5624  			l = len(s)
  5625  			n += 1 + l + sov(uint64(l))
  5626  		}
  5627  	}
  5628  	n += len(m.unknownFields)
  5629  	return n
  5630  }
  5631  
  5632  func (m *ResetReplicationRequest) SizeVT() (n int) {
  5633  	if m == nil {
  5634  		return 0
  5635  	}
  5636  	var l int
  5637  	_ = l
  5638  	n += len(m.unknownFields)
  5639  	return n
  5640  }
  5641  
  5642  func (m *ResetReplicationResponse) SizeVT() (n int) {
  5643  	if m == nil {
  5644  		return 0
  5645  	}
  5646  	var l int
  5647  	_ = l
  5648  	n += len(m.unknownFields)
  5649  	return n
  5650  }
  5651  
  5652  func (m *VReplicationExecRequest) SizeVT() (n int) {
  5653  	if m == nil {
  5654  		return 0
  5655  	}
  5656  	var l int
  5657  	_ = l
  5658  	l = len(m.Query)
  5659  	if l > 0 {
  5660  		n += 1 + l + sov(uint64(l))
  5661  	}
  5662  	n += len(m.unknownFields)
  5663  	return n
  5664  }
  5665  
  5666  func (m *VReplicationExecResponse) SizeVT() (n int) {
  5667  	if m == nil {
  5668  		return 0
  5669  	}
  5670  	var l int
  5671  	_ = l
  5672  	if m.Result != nil {
  5673  		l = m.Result.SizeVT()
  5674  		n += 1 + l + sov(uint64(l))
  5675  	}
  5676  	n += len(m.unknownFields)
  5677  	return n
  5678  }
  5679  
  5680  func (m *VReplicationWaitForPosRequest) SizeVT() (n int) {
  5681  	if m == nil {
  5682  		return 0
  5683  	}
  5684  	var l int
  5685  	_ = l
  5686  	if m.Id != 0 {
  5687  		n += 1 + sov(uint64(m.Id))
  5688  	}
  5689  	l = len(m.Position)
  5690  	if l > 0 {
  5691  		n += 1 + l + sov(uint64(l))
  5692  	}
  5693  	n += len(m.unknownFields)
  5694  	return n
  5695  }
  5696  
  5697  func (m *VReplicationWaitForPosResponse) SizeVT() (n int) {
  5698  	if m == nil {
  5699  		return 0
  5700  	}
  5701  	var l int
  5702  	_ = l
  5703  	n += len(m.unknownFields)
  5704  	return n
  5705  }
  5706  
  5707  func (m *InitPrimaryRequest) SizeVT() (n int) {
  5708  	if m == nil {
  5709  		return 0
  5710  	}
  5711  	var l int
  5712  	_ = l
  5713  	if m.SemiSync {
  5714  		n += 2
  5715  	}
  5716  	n += len(m.unknownFields)
  5717  	return n
  5718  }
  5719  
  5720  func (m *InitPrimaryResponse) SizeVT() (n int) {
  5721  	if m == nil {
  5722  		return 0
  5723  	}
  5724  	var l int
  5725  	_ = l
  5726  	l = len(m.Position)
  5727  	if l > 0 {
  5728  		n += 1 + l + sov(uint64(l))
  5729  	}
  5730  	n += len(m.unknownFields)
  5731  	return n
  5732  }
  5733  
  5734  func (m *PopulateReparentJournalRequest) SizeVT() (n int) {
  5735  	if m == nil {
  5736  		return 0
  5737  	}
  5738  	var l int
  5739  	_ = l
  5740  	if m.TimeCreatedNs != 0 {
  5741  		n += 1 + sov(uint64(m.TimeCreatedNs))
  5742  	}
  5743  	l = len(m.ActionName)
  5744  	if l > 0 {
  5745  		n += 1 + l + sov(uint64(l))
  5746  	}
  5747  	if m.PrimaryAlias != nil {
  5748  		l = m.PrimaryAlias.SizeVT()
  5749  		n += 1 + l + sov(uint64(l))
  5750  	}
  5751  	l = len(m.ReplicationPosition)
  5752  	if l > 0 {
  5753  		n += 1 + l + sov(uint64(l))
  5754  	}
  5755  	n += len(m.unknownFields)
  5756  	return n
  5757  }
  5758  
  5759  func (m *PopulateReparentJournalResponse) SizeVT() (n int) {
  5760  	if m == nil {
  5761  		return 0
  5762  	}
  5763  	var l int
  5764  	_ = l
  5765  	n += len(m.unknownFields)
  5766  	return n
  5767  }
  5768  
  5769  func (m *InitReplicaRequest) SizeVT() (n int) {
  5770  	if m == nil {
  5771  		return 0
  5772  	}
  5773  	var l int
  5774  	_ = l
  5775  	if m.Parent != nil {
  5776  		l = m.Parent.SizeVT()
  5777  		n += 1 + l + sov(uint64(l))
  5778  	}
  5779  	l = len(m.ReplicationPosition)
  5780  	if l > 0 {
  5781  		n += 1 + l + sov(uint64(l))
  5782  	}
  5783  	if m.TimeCreatedNs != 0 {
  5784  		n += 1 + sov(uint64(m.TimeCreatedNs))
  5785  	}
  5786  	if m.SemiSync {
  5787  		n += 2
  5788  	}
  5789  	n += len(m.unknownFields)
  5790  	return n
  5791  }
  5792  
  5793  func (m *InitReplicaResponse) SizeVT() (n int) {
  5794  	if m == nil {
  5795  		return 0
  5796  	}
  5797  	var l int
  5798  	_ = l
  5799  	n += len(m.unknownFields)
  5800  	return n
  5801  }
  5802  
  5803  func (m *DemotePrimaryRequest) SizeVT() (n int) {
  5804  	if m == nil {
  5805  		return 0
  5806  	}
  5807  	var l int
  5808  	_ = l
  5809  	n += len(m.unknownFields)
  5810  	return n
  5811  }
  5812  
  5813  func (m *DemotePrimaryResponse) SizeVT() (n int) {
  5814  	if m == nil {
  5815  		return 0
  5816  	}
  5817  	var l int
  5818  	_ = l
  5819  	if m.PrimaryStatus != nil {
  5820  		l = m.PrimaryStatus.SizeVT()
  5821  		n += 1 + l + sov(uint64(l))
  5822  	}
  5823  	n += len(m.unknownFields)
  5824  	return n
  5825  }
  5826  
  5827  func (m *UndoDemotePrimaryRequest) SizeVT() (n int) {
  5828  	if m == nil {
  5829  		return 0
  5830  	}
  5831  	var l int
  5832  	_ = l
  5833  	if m.SemiSync {
  5834  		n += 2
  5835  	}
  5836  	n += len(m.unknownFields)
  5837  	return n
  5838  }
  5839  
  5840  func (m *UndoDemotePrimaryResponse) SizeVT() (n int) {
  5841  	if m == nil {
  5842  		return 0
  5843  	}
  5844  	var l int
  5845  	_ = l
  5846  	n += len(m.unknownFields)
  5847  	return n
  5848  }
  5849  
  5850  func (m *ReplicaWasPromotedRequest) SizeVT() (n int) {
  5851  	if m == nil {
  5852  		return 0
  5853  	}
  5854  	var l int
  5855  	_ = l
  5856  	n += len(m.unknownFields)
  5857  	return n
  5858  }
  5859  
  5860  func (m *ReplicaWasPromotedResponse) SizeVT() (n int) {
  5861  	if m == nil {
  5862  		return 0
  5863  	}
  5864  	var l int
  5865  	_ = l
  5866  	n += len(m.unknownFields)
  5867  	return n
  5868  }
  5869  
  5870  func (m *ResetReplicationParametersRequest) SizeVT() (n int) {
  5871  	if m == nil {
  5872  		return 0
  5873  	}
  5874  	var l int
  5875  	_ = l
  5876  	n += len(m.unknownFields)
  5877  	return n
  5878  }
  5879  
  5880  func (m *ResetReplicationParametersResponse) SizeVT() (n int) {
  5881  	if m == nil {
  5882  		return 0
  5883  	}
  5884  	var l int
  5885  	_ = l
  5886  	n += len(m.unknownFields)
  5887  	return n
  5888  }
  5889  
  5890  func (m *FullStatusRequest) SizeVT() (n int) {
  5891  	if m == nil {
  5892  		return 0
  5893  	}
  5894  	var l int
  5895  	_ = l
  5896  	n += len(m.unknownFields)
  5897  	return n
  5898  }
  5899  
  5900  func (m *FullStatusResponse) SizeVT() (n int) {
  5901  	if m == nil {
  5902  		return 0
  5903  	}
  5904  	var l int
  5905  	_ = l
  5906  	if m.Status != nil {
  5907  		l = m.Status.SizeVT()
  5908  		n += 1 + l + sov(uint64(l))
  5909  	}
  5910  	n += len(m.unknownFields)
  5911  	return n
  5912  }
  5913  
  5914  func (m *SetReplicationSourceRequest) SizeVT() (n int) {
  5915  	if m == nil {
  5916  		return 0
  5917  	}
  5918  	var l int
  5919  	_ = l
  5920  	if m.Parent != nil {
  5921  		l = m.Parent.SizeVT()
  5922  		n += 1 + l + sov(uint64(l))
  5923  	}
  5924  	if m.TimeCreatedNs != 0 {
  5925  		n += 1 + sov(uint64(m.TimeCreatedNs))
  5926  	}
  5927  	if m.ForceStartReplication {
  5928  		n += 2
  5929  	}
  5930  	l = len(m.WaitPosition)
  5931  	if l > 0 {
  5932  		n += 1 + l + sov(uint64(l))
  5933  	}
  5934  	if m.SemiSync {
  5935  		n += 2
  5936  	}
  5937  	n += len(m.unknownFields)
  5938  	return n
  5939  }
  5940  
  5941  func (m *SetReplicationSourceResponse) SizeVT() (n int) {
  5942  	if m == nil {
  5943  		return 0
  5944  	}
  5945  	var l int
  5946  	_ = l
  5947  	n += len(m.unknownFields)
  5948  	return n
  5949  }
  5950  
  5951  func (m *ReplicaWasRestartedRequest) SizeVT() (n int) {
  5952  	if m == nil {
  5953  		return 0
  5954  	}
  5955  	var l int
  5956  	_ = l
  5957  	if m.Parent != nil {
  5958  		l = m.Parent.SizeVT()
  5959  		n += 1 + l + sov(uint64(l))
  5960  	}
  5961  	n += len(m.unknownFields)
  5962  	return n
  5963  }
  5964  
  5965  func (m *ReplicaWasRestartedResponse) SizeVT() (n int) {
  5966  	if m == nil {
  5967  		return 0
  5968  	}
  5969  	var l int
  5970  	_ = l
  5971  	n += len(m.unknownFields)
  5972  	return n
  5973  }
  5974  
  5975  func (m *StopReplicationAndGetStatusRequest) SizeVT() (n int) {
  5976  	if m == nil {
  5977  		return 0
  5978  	}
  5979  	var l int
  5980  	_ = l
  5981  	if m.StopReplicationMode != 0 {
  5982  		n += 1 + sov(uint64(m.StopReplicationMode))
  5983  	}
  5984  	n += len(m.unknownFields)
  5985  	return n
  5986  }
  5987  
  5988  func (m *StopReplicationAndGetStatusResponse) SizeVT() (n int) {
  5989  	if m == nil {
  5990  		return 0
  5991  	}
  5992  	var l int
  5993  	_ = l
  5994  	if m.Status != nil {
  5995  		l = m.Status.SizeVT()
  5996  		n += 1 + l + sov(uint64(l))
  5997  	}
  5998  	n += len(m.unknownFields)
  5999  	return n
  6000  }
  6001  
  6002  func (m *PromoteReplicaRequest) SizeVT() (n int) {
  6003  	if m == nil {
  6004  		return 0
  6005  	}
  6006  	var l int
  6007  	_ = l
  6008  	if m.SemiSync {
  6009  		n += 2
  6010  	}
  6011  	n += len(m.unknownFields)
  6012  	return n
  6013  }
  6014  
  6015  func (m *PromoteReplicaResponse) SizeVT() (n int) {
  6016  	if m == nil {
  6017  		return 0
  6018  	}
  6019  	var l int
  6020  	_ = l
  6021  	l = len(m.Position)
  6022  	if l > 0 {
  6023  		n += 1 + l + sov(uint64(l))
  6024  	}
  6025  	n += len(m.unknownFields)
  6026  	return n
  6027  }
  6028  
  6029  func (m *BackupRequest) SizeVT() (n int) {
  6030  	if m == nil {
  6031  		return 0
  6032  	}
  6033  	var l int
  6034  	_ = l
  6035  	if m.Concurrency != 0 {
  6036  		n += 1 + sov(uint64(m.Concurrency))
  6037  	}
  6038  	if m.AllowPrimary {
  6039  		n += 2
  6040  	}
  6041  	l = len(m.IncrementalFromPos)
  6042  	if l > 0 {
  6043  		n += 1 + l + sov(uint64(l))
  6044  	}
  6045  	n += len(m.unknownFields)
  6046  	return n
  6047  }
  6048  
  6049  func (m *BackupResponse) SizeVT() (n int) {
  6050  	if m == nil {
  6051  		return 0
  6052  	}
  6053  	var l int
  6054  	_ = l
  6055  	if m.Event != nil {
  6056  		l = m.Event.SizeVT()
  6057  		n += 1 + l + sov(uint64(l))
  6058  	}
  6059  	n += len(m.unknownFields)
  6060  	return n
  6061  }
  6062  
  6063  func (m *RestoreFromBackupRequest) SizeVT() (n int) {
  6064  	if m == nil {
  6065  		return 0
  6066  	}
  6067  	var l int
  6068  	_ = l
  6069  	if m.BackupTime != nil {
  6070  		l = m.BackupTime.SizeVT()
  6071  		n += 1 + l + sov(uint64(l))
  6072  	}
  6073  	l = len(m.RestoreToPos)
  6074  	if l > 0 {
  6075  		n += 1 + l + sov(uint64(l))
  6076  	}
  6077  	if m.DryRun {
  6078  		n += 2
  6079  	}
  6080  	n += len(m.unknownFields)
  6081  	return n
  6082  }
  6083  
  6084  func (m *RestoreFromBackupResponse) SizeVT() (n int) {
  6085  	if m == nil {
  6086  		return 0
  6087  	}
  6088  	var l int
  6089  	_ = l
  6090  	if m.Event != nil {
  6091  		l = m.Event.SizeVT()
  6092  		n += 1 + l + sov(uint64(l))
  6093  	}
  6094  	n += len(m.unknownFields)
  6095  	return n
  6096  }
  6097  
  6098  func (m *VExecRequest) SizeVT() (n int) {
  6099  	if m == nil {
  6100  		return 0
  6101  	}
  6102  	var l int
  6103  	_ = l
  6104  	l = len(m.Query)
  6105  	if l > 0 {
  6106  		n += 1 + l + sov(uint64(l))
  6107  	}
  6108  	l = len(m.Workflow)
  6109  	if l > 0 {
  6110  		n += 1 + l + sov(uint64(l))
  6111  	}
  6112  	l = len(m.Keyspace)
  6113  	if l > 0 {
  6114  		n += 1 + l + sov(uint64(l))
  6115  	}
  6116  	n += len(m.unknownFields)
  6117  	return n
  6118  }
  6119  
  6120  func (m *VExecResponse) SizeVT() (n int) {
  6121  	if m == nil {
  6122  		return 0
  6123  	}
  6124  	var l int
  6125  	_ = l
  6126  	if m.Result != nil {
  6127  		l = m.Result.SizeVT()
  6128  		n += 1 + l + sov(uint64(l))
  6129  	}
  6130  	n += len(m.unknownFields)
  6131  	return n
  6132  }
  6133  
  6134  func (m *VDiffRequest) SizeVT() (n int) {
  6135  	if m == nil {
  6136  		return 0
  6137  	}
  6138  	var l int
  6139  	_ = l
  6140  	l = len(m.Keyspace)
  6141  	if l > 0 {
  6142  		n += 1 + l + sov(uint64(l))
  6143  	}
  6144  	l = len(m.Workflow)
  6145  	if l > 0 {
  6146  		n += 1 + l + sov(uint64(l))
  6147  	}
  6148  	l = len(m.Action)
  6149  	if l > 0 {
  6150  		n += 1 + l + sov(uint64(l))
  6151  	}
  6152  	l = len(m.ActionArg)
  6153  	if l > 0 {
  6154  		n += 1 + l + sov(uint64(l))
  6155  	}
  6156  	l = len(m.VdiffUuid)
  6157  	if l > 0 {
  6158  		n += 1 + l + sov(uint64(l))
  6159  	}
  6160  	if m.Options != nil {
  6161  		l = m.Options.SizeVT()
  6162  		n += 1 + l + sov(uint64(l))
  6163  	}
  6164  	n += len(m.unknownFields)
  6165  	return n
  6166  }
  6167  
  6168  func (m *VDiffResponse) SizeVT() (n int) {
  6169  	if m == nil {
  6170  		return 0
  6171  	}
  6172  	var l int
  6173  	_ = l
  6174  	if m.Id != 0 {
  6175  		n += 1 + sov(uint64(m.Id))
  6176  	}
  6177  	if m.Output != nil {
  6178  		l = m.Output.SizeVT()
  6179  		n += 1 + l + sov(uint64(l))
  6180  	}
  6181  	l = len(m.VdiffUuid)
  6182  	if l > 0 {
  6183  		n += 1 + l + sov(uint64(l))
  6184  	}
  6185  	n += len(m.unknownFields)
  6186  	return n
  6187  }
  6188  
  6189  func (m *VDiffPickerOptions) SizeVT() (n int) {
  6190  	if m == nil {
  6191  		return 0
  6192  	}
  6193  	var l int
  6194  	_ = l
  6195  	l = len(m.TabletTypes)
  6196  	if l > 0 {
  6197  		n += 1 + l + sov(uint64(l))
  6198  	}
  6199  	l = len(m.SourceCell)
  6200  	if l > 0 {
  6201  		n += 1 + l + sov(uint64(l))
  6202  	}
  6203  	l = len(m.TargetCell)
  6204  	if l > 0 {
  6205  		n += 1 + l + sov(uint64(l))
  6206  	}
  6207  	n += len(m.unknownFields)
  6208  	return n
  6209  }
  6210  
  6211  func (m *VDiffReportOptions) SizeVT() (n int) {
  6212  	if m == nil {
  6213  		return 0
  6214  	}
  6215  	var l int
  6216  	_ = l
  6217  	if m.OnlyPks {
  6218  		n += 2
  6219  	}
  6220  	if m.DebugQuery {
  6221  		n += 2
  6222  	}
  6223  	l = len(m.Format)
  6224  	if l > 0 {
  6225  		n += 1 + l + sov(uint64(l))
  6226  	}
  6227  	n += len(m.unknownFields)
  6228  	return n
  6229  }
  6230  
  6231  func (m *VDiffCoreOptions) SizeVT() (n int) {
  6232  	if m == nil {
  6233  		return 0
  6234  	}
  6235  	var l int
  6236  	_ = l
  6237  	l = len(m.Tables)
  6238  	if l > 0 {
  6239  		n += 1 + l + sov(uint64(l))
  6240  	}
  6241  	if m.AutoRetry {
  6242  		n += 2
  6243  	}
  6244  	if m.MaxRows != 0 {
  6245  		n += 1 + sov(uint64(m.MaxRows))
  6246  	}
  6247  	if m.Checksum {
  6248  		n += 2
  6249  	}
  6250  	if m.SamplePct != 0 {
  6251  		n += 1 + sov(uint64(m.SamplePct))
  6252  	}
  6253  	if m.TimeoutSeconds != 0 {
  6254  		n += 1 + sov(uint64(m.TimeoutSeconds))
  6255  	}
  6256  	if m.MaxExtraRowsToCompare != 0 {
  6257  		n += 1 + sov(uint64(m.MaxExtraRowsToCompare))
  6258  	}
  6259  	n += len(m.unknownFields)
  6260  	return n
  6261  }
  6262  
  6263  func (m *VDiffOptions) SizeVT() (n int) {
  6264  	if m == nil {
  6265  		return 0
  6266  	}
  6267  	var l int
  6268  	_ = l
  6269  	if m.PickerOptions != nil {
  6270  		l = m.PickerOptions.SizeVT()
  6271  		n += 1 + l + sov(uint64(l))
  6272  	}
  6273  	if m.CoreOptions != nil {
  6274  		l = m.CoreOptions.SizeVT()
  6275  		n += 1 + l + sov(uint64(l))
  6276  	}
  6277  	if m.ReportOptions != nil {
  6278  		l = m.ReportOptions.SizeVT()
  6279  		n += 1 + l + sov(uint64(l))
  6280  	}
  6281  	n += len(m.unknownFields)
  6282  	return n
  6283  }
  6284  
  6285  func sov(x uint64) (n int) {
  6286  	return (bits.Len64(x|1) + 6) / 7
  6287  }
  6288  func soz(x uint64) (n int) {
  6289  	return sov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  6290  }
  6291  func (m *TableDefinition) UnmarshalVT(dAtA []byte) error {
  6292  	l := len(dAtA)
  6293  	iNdEx := 0
  6294  	for iNdEx < l {
  6295  		preIndex := iNdEx
  6296  		var wire uint64
  6297  		for shift := uint(0); ; shift += 7 {
  6298  			if shift >= 64 {
  6299  				return ErrIntOverflow
  6300  			}
  6301  			if iNdEx >= l {
  6302  				return io.ErrUnexpectedEOF
  6303  			}
  6304  			b := dAtA[iNdEx]
  6305  			iNdEx++
  6306  			wire |= uint64(b&0x7F) << shift
  6307  			if b < 0x80 {
  6308  				break
  6309  			}
  6310  		}
  6311  		fieldNum := int32(wire >> 3)
  6312  		wireType := int(wire & 0x7)
  6313  		if wireType == 4 {
  6314  			return fmt.Errorf("proto: TableDefinition: wiretype end group for non-group")
  6315  		}
  6316  		if fieldNum <= 0 {
  6317  			return fmt.Errorf("proto: TableDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
  6318  		}
  6319  		switch fieldNum {
  6320  		case 1:
  6321  			if wireType != 2 {
  6322  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  6323  			}
  6324  			var stringLen uint64
  6325  			for shift := uint(0); ; shift += 7 {
  6326  				if shift >= 64 {
  6327  					return ErrIntOverflow
  6328  				}
  6329  				if iNdEx >= l {
  6330  					return io.ErrUnexpectedEOF
  6331  				}
  6332  				b := dAtA[iNdEx]
  6333  				iNdEx++
  6334  				stringLen |= uint64(b&0x7F) << shift
  6335  				if b < 0x80 {
  6336  					break
  6337  				}
  6338  			}
  6339  			intStringLen := int(stringLen)
  6340  			if intStringLen < 0 {
  6341  				return ErrInvalidLength
  6342  			}
  6343  			postIndex := iNdEx + intStringLen
  6344  			if postIndex < 0 {
  6345  				return ErrInvalidLength
  6346  			}
  6347  			if postIndex > l {
  6348  				return io.ErrUnexpectedEOF
  6349  			}
  6350  			m.Name = string(dAtA[iNdEx:postIndex])
  6351  			iNdEx = postIndex
  6352  		case 2:
  6353  			if wireType != 2 {
  6354  				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
  6355  			}
  6356  			var stringLen uint64
  6357  			for shift := uint(0); ; shift += 7 {
  6358  				if shift >= 64 {
  6359  					return ErrIntOverflow
  6360  				}
  6361  				if iNdEx >= l {
  6362  					return io.ErrUnexpectedEOF
  6363  				}
  6364  				b := dAtA[iNdEx]
  6365  				iNdEx++
  6366  				stringLen |= uint64(b&0x7F) << shift
  6367  				if b < 0x80 {
  6368  					break
  6369  				}
  6370  			}
  6371  			intStringLen := int(stringLen)
  6372  			if intStringLen < 0 {
  6373  				return ErrInvalidLength
  6374  			}
  6375  			postIndex := iNdEx + intStringLen
  6376  			if postIndex < 0 {
  6377  				return ErrInvalidLength
  6378  			}
  6379  			if postIndex > l {
  6380  				return io.ErrUnexpectedEOF
  6381  			}
  6382  			m.Schema = string(dAtA[iNdEx:postIndex])
  6383  			iNdEx = postIndex
  6384  		case 3:
  6385  			if wireType != 2 {
  6386  				return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
  6387  			}
  6388  			var stringLen uint64
  6389  			for shift := uint(0); ; shift += 7 {
  6390  				if shift >= 64 {
  6391  					return ErrIntOverflow
  6392  				}
  6393  				if iNdEx >= l {
  6394  					return io.ErrUnexpectedEOF
  6395  				}
  6396  				b := dAtA[iNdEx]
  6397  				iNdEx++
  6398  				stringLen |= uint64(b&0x7F) << shift
  6399  				if b < 0x80 {
  6400  					break
  6401  				}
  6402  			}
  6403  			intStringLen := int(stringLen)
  6404  			if intStringLen < 0 {
  6405  				return ErrInvalidLength
  6406  			}
  6407  			postIndex := iNdEx + intStringLen
  6408  			if postIndex < 0 {
  6409  				return ErrInvalidLength
  6410  			}
  6411  			if postIndex > l {
  6412  				return io.ErrUnexpectedEOF
  6413  			}
  6414  			m.Columns = append(m.Columns, string(dAtA[iNdEx:postIndex]))
  6415  			iNdEx = postIndex
  6416  		case 4:
  6417  			if wireType != 2 {
  6418  				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKeyColumns", wireType)
  6419  			}
  6420  			var stringLen uint64
  6421  			for shift := uint(0); ; shift += 7 {
  6422  				if shift >= 64 {
  6423  					return ErrIntOverflow
  6424  				}
  6425  				if iNdEx >= l {
  6426  					return io.ErrUnexpectedEOF
  6427  				}
  6428  				b := dAtA[iNdEx]
  6429  				iNdEx++
  6430  				stringLen |= uint64(b&0x7F) << shift
  6431  				if b < 0x80 {
  6432  					break
  6433  				}
  6434  			}
  6435  			intStringLen := int(stringLen)
  6436  			if intStringLen < 0 {
  6437  				return ErrInvalidLength
  6438  			}
  6439  			postIndex := iNdEx + intStringLen
  6440  			if postIndex < 0 {
  6441  				return ErrInvalidLength
  6442  			}
  6443  			if postIndex > l {
  6444  				return io.ErrUnexpectedEOF
  6445  			}
  6446  			m.PrimaryKeyColumns = append(m.PrimaryKeyColumns, string(dAtA[iNdEx:postIndex]))
  6447  			iNdEx = postIndex
  6448  		case 5:
  6449  			if wireType != 2 {
  6450  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  6451  			}
  6452  			var stringLen uint64
  6453  			for shift := uint(0); ; shift += 7 {
  6454  				if shift >= 64 {
  6455  					return ErrIntOverflow
  6456  				}
  6457  				if iNdEx >= l {
  6458  					return io.ErrUnexpectedEOF
  6459  				}
  6460  				b := dAtA[iNdEx]
  6461  				iNdEx++
  6462  				stringLen |= uint64(b&0x7F) << shift
  6463  				if b < 0x80 {
  6464  					break
  6465  				}
  6466  			}
  6467  			intStringLen := int(stringLen)
  6468  			if intStringLen < 0 {
  6469  				return ErrInvalidLength
  6470  			}
  6471  			postIndex := iNdEx + intStringLen
  6472  			if postIndex < 0 {
  6473  				return ErrInvalidLength
  6474  			}
  6475  			if postIndex > l {
  6476  				return io.ErrUnexpectedEOF
  6477  			}
  6478  			m.Type = string(dAtA[iNdEx:postIndex])
  6479  			iNdEx = postIndex
  6480  		case 6:
  6481  			if wireType != 0 {
  6482  				return fmt.Errorf("proto: wrong wireType = %d for field DataLength", wireType)
  6483  			}
  6484  			m.DataLength = 0
  6485  			for shift := uint(0); ; shift += 7 {
  6486  				if shift >= 64 {
  6487  					return ErrIntOverflow
  6488  				}
  6489  				if iNdEx >= l {
  6490  					return io.ErrUnexpectedEOF
  6491  				}
  6492  				b := dAtA[iNdEx]
  6493  				iNdEx++
  6494  				m.DataLength |= uint64(b&0x7F) << shift
  6495  				if b < 0x80 {
  6496  					break
  6497  				}
  6498  			}
  6499  		case 7:
  6500  			if wireType != 0 {
  6501  				return fmt.Errorf("proto: wrong wireType = %d for field RowCount", wireType)
  6502  			}
  6503  			m.RowCount = 0
  6504  			for shift := uint(0); ; shift += 7 {
  6505  				if shift >= 64 {
  6506  					return ErrIntOverflow
  6507  				}
  6508  				if iNdEx >= l {
  6509  					return io.ErrUnexpectedEOF
  6510  				}
  6511  				b := dAtA[iNdEx]
  6512  				iNdEx++
  6513  				m.RowCount |= uint64(b&0x7F) << shift
  6514  				if b < 0x80 {
  6515  					break
  6516  				}
  6517  			}
  6518  		case 8:
  6519  			if wireType != 2 {
  6520  				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
  6521  			}
  6522  			var msglen int
  6523  			for shift := uint(0); ; shift += 7 {
  6524  				if shift >= 64 {
  6525  					return ErrIntOverflow
  6526  				}
  6527  				if iNdEx >= l {
  6528  					return io.ErrUnexpectedEOF
  6529  				}
  6530  				b := dAtA[iNdEx]
  6531  				iNdEx++
  6532  				msglen |= int(b&0x7F) << shift
  6533  				if b < 0x80 {
  6534  					break
  6535  				}
  6536  			}
  6537  			if msglen < 0 {
  6538  				return ErrInvalidLength
  6539  			}
  6540  			postIndex := iNdEx + msglen
  6541  			if postIndex < 0 {
  6542  				return ErrInvalidLength
  6543  			}
  6544  			if postIndex > l {
  6545  				return io.ErrUnexpectedEOF
  6546  			}
  6547  			m.Fields = append(m.Fields, &query.Field{})
  6548  			if err := m.Fields[len(m.Fields)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  6549  				return err
  6550  			}
  6551  			iNdEx = postIndex
  6552  		default:
  6553  			iNdEx = preIndex
  6554  			skippy, err := skip(dAtA[iNdEx:])
  6555  			if err != nil {
  6556  				return err
  6557  			}
  6558  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6559  				return ErrInvalidLength
  6560  			}
  6561  			if (iNdEx + skippy) > l {
  6562  				return io.ErrUnexpectedEOF
  6563  			}
  6564  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6565  			iNdEx += skippy
  6566  		}
  6567  	}
  6568  
  6569  	if iNdEx > l {
  6570  		return io.ErrUnexpectedEOF
  6571  	}
  6572  	return nil
  6573  }
  6574  func (m *SchemaDefinition) UnmarshalVT(dAtA []byte) error {
  6575  	l := len(dAtA)
  6576  	iNdEx := 0
  6577  	for iNdEx < l {
  6578  		preIndex := iNdEx
  6579  		var wire uint64
  6580  		for shift := uint(0); ; shift += 7 {
  6581  			if shift >= 64 {
  6582  				return ErrIntOverflow
  6583  			}
  6584  			if iNdEx >= l {
  6585  				return io.ErrUnexpectedEOF
  6586  			}
  6587  			b := dAtA[iNdEx]
  6588  			iNdEx++
  6589  			wire |= uint64(b&0x7F) << shift
  6590  			if b < 0x80 {
  6591  				break
  6592  			}
  6593  		}
  6594  		fieldNum := int32(wire >> 3)
  6595  		wireType := int(wire & 0x7)
  6596  		if wireType == 4 {
  6597  			return fmt.Errorf("proto: SchemaDefinition: wiretype end group for non-group")
  6598  		}
  6599  		if fieldNum <= 0 {
  6600  			return fmt.Errorf("proto: SchemaDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
  6601  		}
  6602  		switch fieldNum {
  6603  		case 1:
  6604  			if wireType != 2 {
  6605  				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseSchema", wireType)
  6606  			}
  6607  			var stringLen uint64
  6608  			for shift := uint(0); ; shift += 7 {
  6609  				if shift >= 64 {
  6610  					return ErrIntOverflow
  6611  				}
  6612  				if iNdEx >= l {
  6613  					return io.ErrUnexpectedEOF
  6614  				}
  6615  				b := dAtA[iNdEx]
  6616  				iNdEx++
  6617  				stringLen |= uint64(b&0x7F) << shift
  6618  				if b < 0x80 {
  6619  					break
  6620  				}
  6621  			}
  6622  			intStringLen := int(stringLen)
  6623  			if intStringLen < 0 {
  6624  				return ErrInvalidLength
  6625  			}
  6626  			postIndex := iNdEx + intStringLen
  6627  			if postIndex < 0 {
  6628  				return ErrInvalidLength
  6629  			}
  6630  			if postIndex > l {
  6631  				return io.ErrUnexpectedEOF
  6632  			}
  6633  			m.DatabaseSchema = string(dAtA[iNdEx:postIndex])
  6634  			iNdEx = postIndex
  6635  		case 2:
  6636  			if wireType != 2 {
  6637  				return fmt.Errorf("proto: wrong wireType = %d for field TableDefinitions", wireType)
  6638  			}
  6639  			var msglen int
  6640  			for shift := uint(0); ; shift += 7 {
  6641  				if shift >= 64 {
  6642  					return ErrIntOverflow
  6643  				}
  6644  				if iNdEx >= l {
  6645  					return io.ErrUnexpectedEOF
  6646  				}
  6647  				b := dAtA[iNdEx]
  6648  				iNdEx++
  6649  				msglen |= int(b&0x7F) << shift
  6650  				if b < 0x80 {
  6651  					break
  6652  				}
  6653  			}
  6654  			if msglen < 0 {
  6655  				return ErrInvalidLength
  6656  			}
  6657  			postIndex := iNdEx + msglen
  6658  			if postIndex < 0 {
  6659  				return ErrInvalidLength
  6660  			}
  6661  			if postIndex > l {
  6662  				return io.ErrUnexpectedEOF
  6663  			}
  6664  			m.TableDefinitions = append(m.TableDefinitions, &TableDefinition{})
  6665  			if err := m.TableDefinitions[len(m.TableDefinitions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  6666  				return err
  6667  			}
  6668  			iNdEx = postIndex
  6669  		case 3:
  6670  			if wireType != 2 {
  6671  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  6672  			}
  6673  			var stringLen uint64
  6674  			for shift := uint(0); ; shift += 7 {
  6675  				if shift >= 64 {
  6676  					return ErrIntOverflow
  6677  				}
  6678  				if iNdEx >= l {
  6679  					return io.ErrUnexpectedEOF
  6680  				}
  6681  				b := dAtA[iNdEx]
  6682  				iNdEx++
  6683  				stringLen |= uint64(b&0x7F) << shift
  6684  				if b < 0x80 {
  6685  					break
  6686  				}
  6687  			}
  6688  			intStringLen := int(stringLen)
  6689  			if intStringLen < 0 {
  6690  				return ErrInvalidLength
  6691  			}
  6692  			postIndex := iNdEx + intStringLen
  6693  			if postIndex < 0 {
  6694  				return ErrInvalidLength
  6695  			}
  6696  			if postIndex > l {
  6697  				return io.ErrUnexpectedEOF
  6698  			}
  6699  			m.Version = string(dAtA[iNdEx:postIndex])
  6700  			iNdEx = postIndex
  6701  		default:
  6702  			iNdEx = preIndex
  6703  			skippy, err := skip(dAtA[iNdEx:])
  6704  			if err != nil {
  6705  				return err
  6706  			}
  6707  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6708  				return ErrInvalidLength
  6709  			}
  6710  			if (iNdEx + skippy) > l {
  6711  				return io.ErrUnexpectedEOF
  6712  			}
  6713  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6714  			iNdEx += skippy
  6715  		}
  6716  	}
  6717  
  6718  	if iNdEx > l {
  6719  		return io.ErrUnexpectedEOF
  6720  	}
  6721  	return nil
  6722  }
  6723  func (m *SchemaChangeResult) UnmarshalVT(dAtA []byte) error {
  6724  	l := len(dAtA)
  6725  	iNdEx := 0
  6726  	for iNdEx < l {
  6727  		preIndex := iNdEx
  6728  		var wire uint64
  6729  		for shift := uint(0); ; shift += 7 {
  6730  			if shift >= 64 {
  6731  				return ErrIntOverflow
  6732  			}
  6733  			if iNdEx >= l {
  6734  				return io.ErrUnexpectedEOF
  6735  			}
  6736  			b := dAtA[iNdEx]
  6737  			iNdEx++
  6738  			wire |= uint64(b&0x7F) << shift
  6739  			if b < 0x80 {
  6740  				break
  6741  			}
  6742  		}
  6743  		fieldNum := int32(wire >> 3)
  6744  		wireType := int(wire & 0x7)
  6745  		if wireType == 4 {
  6746  			return fmt.Errorf("proto: SchemaChangeResult: wiretype end group for non-group")
  6747  		}
  6748  		if fieldNum <= 0 {
  6749  			return fmt.Errorf("proto: SchemaChangeResult: illegal tag %d (wire type %d)", fieldNum, wire)
  6750  		}
  6751  		switch fieldNum {
  6752  		case 1:
  6753  			if wireType != 2 {
  6754  				return fmt.Errorf("proto: wrong wireType = %d for field BeforeSchema", wireType)
  6755  			}
  6756  			var msglen int
  6757  			for shift := uint(0); ; shift += 7 {
  6758  				if shift >= 64 {
  6759  					return ErrIntOverflow
  6760  				}
  6761  				if iNdEx >= l {
  6762  					return io.ErrUnexpectedEOF
  6763  				}
  6764  				b := dAtA[iNdEx]
  6765  				iNdEx++
  6766  				msglen |= int(b&0x7F) << shift
  6767  				if b < 0x80 {
  6768  					break
  6769  				}
  6770  			}
  6771  			if msglen < 0 {
  6772  				return ErrInvalidLength
  6773  			}
  6774  			postIndex := iNdEx + msglen
  6775  			if postIndex < 0 {
  6776  				return ErrInvalidLength
  6777  			}
  6778  			if postIndex > l {
  6779  				return io.ErrUnexpectedEOF
  6780  			}
  6781  			if m.BeforeSchema == nil {
  6782  				m.BeforeSchema = &SchemaDefinition{}
  6783  			}
  6784  			if err := m.BeforeSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  6785  				return err
  6786  			}
  6787  			iNdEx = postIndex
  6788  		case 2:
  6789  			if wireType != 2 {
  6790  				return fmt.Errorf("proto: wrong wireType = %d for field AfterSchema", wireType)
  6791  			}
  6792  			var msglen int
  6793  			for shift := uint(0); ; shift += 7 {
  6794  				if shift >= 64 {
  6795  					return ErrIntOverflow
  6796  				}
  6797  				if iNdEx >= l {
  6798  					return io.ErrUnexpectedEOF
  6799  				}
  6800  				b := dAtA[iNdEx]
  6801  				iNdEx++
  6802  				msglen |= int(b&0x7F) << shift
  6803  				if b < 0x80 {
  6804  					break
  6805  				}
  6806  			}
  6807  			if msglen < 0 {
  6808  				return ErrInvalidLength
  6809  			}
  6810  			postIndex := iNdEx + msglen
  6811  			if postIndex < 0 {
  6812  				return ErrInvalidLength
  6813  			}
  6814  			if postIndex > l {
  6815  				return io.ErrUnexpectedEOF
  6816  			}
  6817  			if m.AfterSchema == nil {
  6818  				m.AfterSchema = &SchemaDefinition{}
  6819  			}
  6820  			if err := m.AfterSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  6821  				return err
  6822  			}
  6823  			iNdEx = postIndex
  6824  		default:
  6825  			iNdEx = preIndex
  6826  			skippy, err := skip(dAtA[iNdEx:])
  6827  			if err != nil {
  6828  				return err
  6829  			}
  6830  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6831  				return ErrInvalidLength
  6832  			}
  6833  			if (iNdEx + skippy) > l {
  6834  				return io.ErrUnexpectedEOF
  6835  			}
  6836  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  6837  			iNdEx += skippy
  6838  		}
  6839  	}
  6840  
  6841  	if iNdEx > l {
  6842  		return io.ErrUnexpectedEOF
  6843  	}
  6844  	return nil
  6845  }
  6846  func (m *UserPermission) UnmarshalVT(dAtA []byte) error {
  6847  	l := len(dAtA)
  6848  	iNdEx := 0
  6849  	for iNdEx < l {
  6850  		preIndex := iNdEx
  6851  		var wire uint64
  6852  		for shift := uint(0); ; shift += 7 {
  6853  			if shift >= 64 {
  6854  				return ErrIntOverflow
  6855  			}
  6856  			if iNdEx >= l {
  6857  				return io.ErrUnexpectedEOF
  6858  			}
  6859  			b := dAtA[iNdEx]
  6860  			iNdEx++
  6861  			wire |= uint64(b&0x7F) << shift
  6862  			if b < 0x80 {
  6863  				break
  6864  			}
  6865  		}
  6866  		fieldNum := int32(wire >> 3)
  6867  		wireType := int(wire & 0x7)
  6868  		if wireType == 4 {
  6869  			return fmt.Errorf("proto: UserPermission: wiretype end group for non-group")
  6870  		}
  6871  		if fieldNum <= 0 {
  6872  			return fmt.Errorf("proto: UserPermission: illegal tag %d (wire type %d)", fieldNum, wire)
  6873  		}
  6874  		switch fieldNum {
  6875  		case 1:
  6876  			if wireType != 2 {
  6877  				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
  6878  			}
  6879  			var stringLen uint64
  6880  			for shift := uint(0); ; shift += 7 {
  6881  				if shift >= 64 {
  6882  					return ErrIntOverflow
  6883  				}
  6884  				if iNdEx >= l {
  6885  					return io.ErrUnexpectedEOF
  6886  				}
  6887  				b := dAtA[iNdEx]
  6888  				iNdEx++
  6889  				stringLen |= uint64(b&0x7F) << shift
  6890  				if b < 0x80 {
  6891  					break
  6892  				}
  6893  			}
  6894  			intStringLen := int(stringLen)
  6895  			if intStringLen < 0 {
  6896  				return ErrInvalidLength
  6897  			}
  6898  			postIndex := iNdEx + intStringLen
  6899  			if postIndex < 0 {
  6900  				return ErrInvalidLength
  6901  			}
  6902  			if postIndex > l {
  6903  				return io.ErrUnexpectedEOF
  6904  			}
  6905  			m.Host = string(dAtA[iNdEx:postIndex])
  6906  			iNdEx = postIndex
  6907  		case 2:
  6908  			if wireType != 2 {
  6909  				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
  6910  			}
  6911  			var stringLen uint64
  6912  			for shift := uint(0); ; shift += 7 {
  6913  				if shift >= 64 {
  6914  					return ErrIntOverflow
  6915  				}
  6916  				if iNdEx >= l {
  6917  					return io.ErrUnexpectedEOF
  6918  				}
  6919  				b := dAtA[iNdEx]
  6920  				iNdEx++
  6921  				stringLen |= uint64(b&0x7F) << shift
  6922  				if b < 0x80 {
  6923  					break
  6924  				}
  6925  			}
  6926  			intStringLen := int(stringLen)
  6927  			if intStringLen < 0 {
  6928  				return ErrInvalidLength
  6929  			}
  6930  			postIndex := iNdEx + intStringLen
  6931  			if postIndex < 0 {
  6932  				return ErrInvalidLength
  6933  			}
  6934  			if postIndex > l {
  6935  				return io.ErrUnexpectedEOF
  6936  			}
  6937  			m.User = string(dAtA[iNdEx:postIndex])
  6938  			iNdEx = postIndex
  6939  		case 3:
  6940  			if wireType != 0 {
  6941  				return fmt.Errorf("proto: wrong wireType = %d for field PasswordChecksum", wireType)
  6942  			}
  6943  			m.PasswordChecksum = 0
  6944  			for shift := uint(0); ; shift += 7 {
  6945  				if shift >= 64 {
  6946  					return ErrIntOverflow
  6947  				}
  6948  				if iNdEx >= l {
  6949  					return io.ErrUnexpectedEOF
  6950  				}
  6951  				b := dAtA[iNdEx]
  6952  				iNdEx++
  6953  				m.PasswordChecksum |= uint64(b&0x7F) << shift
  6954  				if b < 0x80 {
  6955  					break
  6956  				}
  6957  			}
  6958  		case 4:
  6959  			if wireType != 2 {
  6960  				return fmt.Errorf("proto: wrong wireType = %d for field Privileges", wireType)
  6961  			}
  6962  			var msglen int
  6963  			for shift := uint(0); ; shift += 7 {
  6964  				if shift >= 64 {
  6965  					return ErrIntOverflow
  6966  				}
  6967  				if iNdEx >= l {
  6968  					return io.ErrUnexpectedEOF
  6969  				}
  6970  				b := dAtA[iNdEx]
  6971  				iNdEx++
  6972  				msglen |= int(b&0x7F) << shift
  6973  				if b < 0x80 {
  6974  					break
  6975  				}
  6976  			}
  6977  			if msglen < 0 {
  6978  				return ErrInvalidLength
  6979  			}
  6980  			postIndex := iNdEx + msglen
  6981  			if postIndex < 0 {
  6982  				return ErrInvalidLength
  6983  			}
  6984  			if postIndex > l {
  6985  				return io.ErrUnexpectedEOF
  6986  			}
  6987  			if m.Privileges == nil {
  6988  				m.Privileges = make(map[string]string)
  6989  			}
  6990  			var mapkey string
  6991  			var mapvalue string
  6992  			for iNdEx < postIndex {
  6993  				entryPreIndex := iNdEx
  6994  				var wire uint64
  6995  				for shift := uint(0); ; shift += 7 {
  6996  					if shift >= 64 {
  6997  						return ErrIntOverflow
  6998  					}
  6999  					if iNdEx >= l {
  7000  						return io.ErrUnexpectedEOF
  7001  					}
  7002  					b := dAtA[iNdEx]
  7003  					iNdEx++
  7004  					wire |= uint64(b&0x7F) << shift
  7005  					if b < 0x80 {
  7006  						break
  7007  					}
  7008  				}
  7009  				fieldNum := int32(wire >> 3)
  7010  				if fieldNum == 1 {
  7011  					var stringLenmapkey uint64
  7012  					for shift := uint(0); ; shift += 7 {
  7013  						if shift >= 64 {
  7014  							return ErrIntOverflow
  7015  						}
  7016  						if iNdEx >= l {
  7017  							return io.ErrUnexpectedEOF
  7018  						}
  7019  						b := dAtA[iNdEx]
  7020  						iNdEx++
  7021  						stringLenmapkey |= uint64(b&0x7F) << shift
  7022  						if b < 0x80 {
  7023  							break
  7024  						}
  7025  					}
  7026  					intStringLenmapkey := int(stringLenmapkey)
  7027  					if intStringLenmapkey < 0 {
  7028  						return ErrInvalidLength
  7029  					}
  7030  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  7031  					if postStringIndexmapkey < 0 {
  7032  						return ErrInvalidLength
  7033  					}
  7034  					if postStringIndexmapkey > l {
  7035  						return io.ErrUnexpectedEOF
  7036  					}
  7037  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  7038  					iNdEx = postStringIndexmapkey
  7039  				} else if fieldNum == 2 {
  7040  					var stringLenmapvalue uint64
  7041  					for shift := uint(0); ; shift += 7 {
  7042  						if shift >= 64 {
  7043  							return ErrIntOverflow
  7044  						}
  7045  						if iNdEx >= l {
  7046  							return io.ErrUnexpectedEOF
  7047  						}
  7048  						b := dAtA[iNdEx]
  7049  						iNdEx++
  7050  						stringLenmapvalue |= uint64(b&0x7F) << shift
  7051  						if b < 0x80 {
  7052  							break
  7053  						}
  7054  					}
  7055  					intStringLenmapvalue := int(stringLenmapvalue)
  7056  					if intStringLenmapvalue < 0 {
  7057  						return ErrInvalidLength
  7058  					}
  7059  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  7060  					if postStringIndexmapvalue < 0 {
  7061  						return ErrInvalidLength
  7062  					}
  7063  					if postStringIndexmapvalue > l {
  7064  						return io.ErrUnexpectedEOF
  7065  					}
  7066  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  7067  					iNdEx = postStringIndexmapvalue
  7068  				} else {
  7069  					iNdEx = entryPreIndex
  7070  					skippy, err := skip(dAtA[iNdEx:])
  7071  					if err != nil {
  7072  						return err
  7073  					}
  7074  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  7075  						return ErrInvalidLength
  7076  					}
  7077  					if (iNdEx + skippy) > postIndex {
  7078  						return io.ErrUnexpectedEOF
  7079  					}
  7080  					iNdEx += skippy
  7081  				}
  7082  			}
  7083  			m.Privileges[mapkey] = mapvalue
  7084  			iNdEx = postIndex
  7085  		default:
  7086  			iNdEx = preIndex
  7087  			skippy, err := skip(dAtA[iNdEx:])
  7088  			if err != nil {
  7089  				return err
  7090  			}
  7091  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7092  				return ErrInvalidLength
  7093  			}
  7094  			if (iNdEx + skippy) > l {
  7095  				return io.ErrUnexpectedEOF
  7096  			}
  7097  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7098  			iNdEx += skippy
  7099  		}
  7100  	}
  7101  
  7102  	if iNdEx > l {
  7103  		return io.ErrUnexpectedEOF
  7104  	}
  7105  	return nil
  7106  }
  7107  func (m *DbPermission) UnmarshalVT(dAtA []byte) error {
  7108  	l := len(dAtA)
  7109  	iNdEx := 0
  7110  	for iNdEx < l {
  7111  		preIndex := iNdEx
  7112  		var wire uint64
  7113  		for shift := uint(0); ; shift += 7 {
  7114  			if shift >= 64 {
  7115  				return ErrIntOverflow
  7116  			}
  7117  			if iNdEx >= l {
  7118  				return io.ErrUnexpectedEOF
  7119  			}
  7120  			b := dAtA[iNdEx]
  7121  			iNdEx++
  7122  			wire |= uint64(b&0x7F) << shift
  7123  			if b < 0x80 {
  7124  				break
  7125  			}
  7126  		}
  7127  		fieldNum := int32(wire >> 3)
  7128  		wireType := int(wire & 0x7)
  7129  		if wireType == 4 {
  7130  			return fmt.Errorf("proto: DbPermission: wiretype end group for non-group")
  7131  		}
  7132  		if fieldNum <= 0 {
  7133  			return fmt.Errorf("proto: DbPermission: illegal tag %d (wire type %d)", fieldNum, wire)
  7134  		}
  7135  		switch fieldNum {
  7136  		case 1:
  7137  			if wireType != 2 {
  7138  				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
  7139  			}
  7140  			var stringLen uint64
  7141  			for shift := uint(0); ; shift += 7 {
  7142  				if shift >= 64 {
  7143  					return ErrIntOverflow
  7144  				}
  7145  				if iNdEx >= l {
  7146  					return io.ErrUnexpectedEOF
  7147  				}
  7148  				b := dAtA[iNdEx]
  7149  				iNdEx++
  7150  				stringLen |= uint64(b&0x7F) << shift
  7151  				if b < 0x80 {
  7152  					break
  7153  				}
  7154  			}
  7155  			intStringLen := int(stringLen)
  7156  			if intStringLen < 0 {
  7157  				return ErrInvalidLength
  7158  			}
  7159  			postIndex := iNdEx + intStringLen
  7160  			if postIndex < 0 {
  7161  				return ErrInvalidLength
  7162  			}
  7163  			if postIndex > l {
  7164  				return io.ErrUnexpectedEOF
  7165  			}
  7166  			m.Host = string(dAtA[iNdEx:postIndex])
  7167  			iNdEx = postIndex
  7168  		case 2:
  7169  			if wireType != 2 {
  7170  				return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType)
  7171  			}
  7172  			var stringLen uint64
  7173  			for shift := uint(0); ; shift += 7 {
  7174  				if shift >= 64 {
  7175  					return ErrIntOverflow
  7176  				}
  7177  				if iNdEx >= l {
  7178  					return io.ErrUnexpectedEOF
  7179  				}
  7180  				b := dAtA[iNdEx]
  7181  				iNdEx++
  7182  				stringLen |= uint64(b&0x7F) << shift
  7183  				if b < 0x80 {
  7184  					break
  7185  				}
  7186  			}
  7187  			intStringLen := int(stringLen)
  7188  			if intStringLen < 0 {
  7189  				return ErrInvalidLength
  7190  			}
  7191  			postIndex := iNdEx + intStringLen
  7192  			if postIndex < 0 {
  7193  				return ErrInvalidLength
  7194  			}
  7195  			if postIndex > l {
  7196  				return io.ErrUnexpectedEOF
  7197  			}
  7198  			m.Db = string(dAtA[iNdEx:postIndex])
  7199  			iNdEx = postIndex
  7200  		case 3:
  7201  			if wireType != 2 {
  7202  				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
  7203  			}
  7204  			var stringLen uint64
  7205  			for shift := uint(0); ; shift += 7 {
  7206  				if shift >= 64 {
  7207  					return ErrIntOverflow
  7208  				}
  7209  				if iNdEx >= l {
  7210  					return io.ErrUnexpectedEOF
  7211  				}
  7212  				b := dAtA[iNdEx]
  7213  				iNdEx++
  7214  				stringLen |= uint64(b&0x7F) << shift
  7215  				if b < 0x80 {
  7216  					break
  7217  				}
  7218  			}
  7219  			intStringLen := int(stringLen)
  7220  			if intStringLen < 0 {
  7221  				return ErrInvalidLength
  7222  			}
  7223  			postIndex := iNdEx + intStringLen
  7224  			if postIndex < 0 {
  7225  				return ErrInvalidLength
  7226  			}
  7227  			if postIndex > l {
  7228  				return io.ErrUnexpectedEOF
  7229  			}
  7230  			m.User = string(dAtA[iNdEx:postIndex])
  7231  			iNdEx = postIndex
  7232  		case 4:
  7233  			if wireType != 2 {
  7234  				return fmt.Errorf("proto: wrong wireType = %d for field Privileges", wireType)
  7235  			}
  7236  			var msglen int
  7237  			for shift := uint(0); ; shift += 7 {
  7238  				if shift >= 64 {
  7239  					return ErrIntOverflow
  7240  				}
  7241  				if iNdEx >= l {
  7242  					return io.ErrUnexpectedEOF
  7243  				}
  7244  				b := dAtA[iNdEx]
  7245  				iNdEx++
  7246  				msglen |= int(b&0x7F) << shift
  7247  				if b < 0x80 {
  7248  					break
  7249  				}
  7250  			}
  7251  			if msglen < 0 {
  7252  				return ErrInvalidLength
  7253  			}
  7254  			postIndex := iNdEx + msglen
  7255  			if postIndex < 0 {
  7256  				return ErrInvalidLength
  7257  			}
  7258  			if postIndex > l {
  7259  				return io.ErrUnexpectedEOF
  7260  			}
  7261  			if m.Privileges == nil {
  7262  				m.Privileges = make(map[string]string)
  7263  			}
  7264  			var mapkey string
  7265  			var mapvalue string
  7266  			for iNdEx < postIndex {
  7267  				entryPreIndex := iNdEx
  7268  				var wire uint64
  7269  				for shift := uint(0); ; shift += 7 {
  7270  					if shift >= 64 {
  7271  						return ErrIntOverflow
  7272  					}
  7273  					if iNdEx >= l {
  7274  						return io.ErrUnexpectedEOF
  7275  					}
  7276  					b := dAtA[iNdEx]
  7277  					iNdEx++
  7278  					wire |= uint64(b&0x7F) << shift
  7279  					if b < 0x80 {
  7280  						break
  7281  					}
  7282  				}
  7283  				fieldNum := int32(wire >> 3)
  7284  				if fieldNum == 1 {
  7285  					var stringLenmapkey uint64
  7286  					for shift := uint(0); ; shift += 7 {
  7287  						if shift >= 64 {
  7288  							return ErrIntOverflow
  7289  						}
  7290  						if iNdEx >= l {
  7291  							return io.ErrUnexpectedEOF
  7292  						}
  7293  						b := dAtA[iNdEx]
  7294  						iNdEx++
  7295  						stringLenmapkey |= uint64(b&0x7F) << shift
  7296  						if b < 0x80 {
  7297  							break
  7298  						}
  7299  					}
  7300  					intStringLenmapkey := int(stringLenmapkey)
  7301  					if intStringLenmapkey < 0 {
  7302  						return ErrInvalidLength
  7303  					}
  7304  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  7305  					if postStringIndexmapkey < 0 {
  7306  						return ErrInvalidLength
  7307  					}
  7308  					if postStringIndexmapkey > l {
  7309  						return io.ErrUnexpectedEOF
  7310  					}
  7311  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  7312  					iNdEx = postStringIndexmapkey
  7313  				} else if fieldNum == 2 {
  7314  					var stringLenmapvalue uint64
  7315  					for shift := uint(0); ; shift += 7 {
  7316  						if shift >= 64 {
  7317  							return ErrIntOverflow
  7318  						}
  7319  						if iNdEx >= l {
  7320  							return io.ErrUnexpectedEOF
  7321  						}
  7322  						b := dAtA[iNdEx]
  7323  						iNdEx++
  7324  						stringLenmapvalue |= uint64(b&0x7F) << shift
  7325  						if b < 0x80 {
  7326  							break
  7327  						}
  7328  					}
  7329  					intStringLenmapvalue := int(stringLenmapvalue)
  7330  					if intStringLenmapvalue < 0 {
  7331  						return ErrInvalidLength
  7332  					}
  7333  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  7334  					if postStringIndexmapvalue < 0 {
  7335  						return ErrInvalidLength
  7336  					}
  7337  					if postStringIndexmapvalue > l {
  7338  						return io.ErrUnexpectedEOF
  7339  					}
  7340  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  7341  					iNdEx = postStringIndexmapvalue
  7342  				} else {
  7343  					iNdEx = entryPreIndex
  7344  					skippy, err := skip(dAtA[iNdEx:])
  7345  					if err != nil {
  7346  						return err
  7347  					}
  7348  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  7349  						return ErrInvalidLength
  7350  					}
  7351  					if (iNdEx + skippy) > postIndex {
  7352  						return io.ErrUnexpectedEOF
  7353  					}
  7354  					iNdEx += skippy
  7355  				}
  7356  			}
  7357  			m.Privileges[mapkey] = mapvalue
  7358  			iNdEx = postIndex
  7359  		default:
  7360  			iNdEx = preIndex
  7361  			skippy, err := skip(dAtA[iNdEx:])
  7362  			if err != nil {
  7363  				return err
  7364  			}
  7365  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7366  				return ErrInvalidLength
  7367  			}
  7368  			if (iNdEx + skippy) > l {
  7369  				return io.ErrUnexpectedEOF
  7370  			}
  7371  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7372  			iNdEx += skippy
  7373  		}
  7374  	}
  7375  
  7376  	if iNdEx > l {
  7377  		return io.ErrUnexpectedEOF
  7378  	}
  7379  	return nil
  7380  }
  7381  func (m *Permissions) UnmarshalVT(dAtA []byte) error {
  7382  	l := len(dAtA)
  7383  	iNdEx := 0
  7384  	for iNdEx < l {
  7385  		preIndex := iNdEx
  7386  		var wire uint64
  7387  		for shift := uint(0); ; shift += 7 {
  7388  			if shift >= 64 {
  7389  				return ErrIntOverflow
  7390  			}
  7391  			if iNdEx >= l {
  7392  				return io.ErrUnexpectedEOF
  7393  			}
  7394  			b := dAtA[iNdEx]
  7395  			iNdEx++
  7396  			wire |= uint64(b&0x7F) << shift
  7397  			if b < 0x80 {
  7398  				break
  7399  			}
  7400  		}
  7401  		fieldNum := int32(wire >> 3)
  7402  		wireType := int(wire & 0x7)
  7403  		if wireType == 4 {
  7404  			return fmt.Errorf("proto: Permissions: wiretype end group for non-group")
  7405  		}
  7406  		if fieldNum <= 0 {
  7407  			return fmt.Errorf("proto: Permissions: illegal tag %d (wire type %d)", fieldNum, wire)
  7408  		}
  7409  		switch fieldNum {
  7410  		case 1:
  7411  			if wireType != 2 {
  7412  				return fmt.Errorf("proto: wrong wireType = %d for field UserPermissions", wireType)
  7413  			}
  7414  			var msglen int
  7415  			for shift := uint(0); ; shift += 7 {
  7416  				if shift >= 64 {
  7417  					return ErrIntOverflow
  7418  				}
  7419  				if iNdEx >= l {
  7420  					return io.ErrUnexpectedEOF
  7421  				}
  7422  				b := dAtA[iNdEx]
  7423  				iNdEx++
  7424  				msglen |= int(b&0x7F) << shift
  7425  				if b < 0x80 {
  7426  					break
  7427  				}
  7428  			}
  7429  			if msglen < 0 {
  7430  				return ErrInvalidLength
  7431  			}
  7432  			postIndex := iNdEx + msglen
  7433  			if postIndex < 0 {
  7434  				return ErrInvalidLength
  7435  			}
  7436  			if postIndex > l {
  7437  				return io.ErrUnexpectedEOF
  7438  			}
  7439  			m.UserPermissions = append(m.UserPermissions, &UserPermission{})
  7440  			if err := m.UserPermissions[len(m.UserPermissions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7441  				return err
  7442  			}
  7443  			iNdEx = postIndex
  7444  		case 2:
  7445  			if wireType != 2 {
  7446  				return fmt.Errorf("proto: wrong wireType = %d for field DbPermissions", wireType)
  7447  			}
  7448  			var msglen int
  7449  			for shift := uint(0); ; shift += 7 {
  7450  				if shift >= 64 {
  7451  					return ErrIntOverflow
  7452  				}
  7453  				if iNdEx >= l {
  7454  					return io.ErrUnexpectedEOF
  7455  				}
  7456  				b := dAtA[iNdEx]
  7457  				iNdEx++
  7458  				msglen |= int(b&0x7F) << shift
  7459  				if b < 0x80 {
  7460  					break
  7461  				}
  7462  			}
  7463  			if msglen < 0 {
  7464  				return ErrInvalidLength
  7465  			}
  7466  			postIndex := iNdEx + msglen
  7467  			if postIndex < 0 {
  7468  				return ErrInvalidLength
  7469  			}
  7470  			if postIndex > l {
  7471  				return io.ErrUnexpectedEOF
  7472  			}
  7473  			m.DbPermissions = append(m.DbPermissions, &DbPermission{})
  7474  			if err := m.DbPermissions[len(m.DbPermissions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  7475  				return err
  7476  			}
  7477  			iNdEx = postIndex
  7478  		default:
  7479  			iNdEx = preIndex
  7480  			skippy, err := skip(dAtA[iNdEx:])
  7481  			if err != nil {
  7482  				return err
  7483  			}
  7484  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7485  				return ErrInvalidLength
  7486  			}
  7487  			if (iNdEx + skippy) > l {
  7488  				return io.ErrUnexpectedEOF
  7489  			}
  7490  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7491  			iNdEx += skippy
  7492  		}
  7493  	}
  7494  
  7495  	if iNdEx > l {
  7496  		return io.ErrUnexpectedEOF
  7497  	}
  7498  	return nil
  7499  }
  7500  func (m *PingRequest) UnmarshalVT(dAtA []byte) error {
  7501  	l := len(dAtA)
  7502  	iNdEx := 0
  7503  	for iNdEx < l {
  7504  		preIndex := iNdEx
  7505  		var wire uint64
  7506  		for shift := uint(0); ; shift += 7 {
  7507  			if shift >= 64 {
  7508  				return ErrIntOverflow
  7509  			}
  7510  			if iNdEx >= l {
  7511  				return io.ErrUnexpectedEOF
  7512  			}
  7513  			b := dAtA[iNdEx]
  7514  			iNdEx++
  7515  			wire |= uint64(b&0x7F) << shift
  7516  			if b < 0x80 {
  7517  				break
  7518  			}
  7519  		}
  7520  		fieldNum := int32(wire >> 3)
  7521  		wireType := int(wire & 0x7)
  7522  		if wireType == 4 {
  7523  			return fmt.Errorf("proto: PingRequest: wiretype end group for non-group")
  7524  		}
  7525  		if fieldNum <= 0 {
  7526  			return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  7527  		}
  7528  		switch fieldNum {
  7529  		case 1:
  7530  			if wireType != 2 {
  7531  				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
  7532  			}
  7533  			var stringLen uint64
  7534  			for shift := uint(0); ; shift += 7 {
  7535  				if shift >= 64 {
  7536  					return ErrIntOverflow
  7537  				}
  7538  				if iNdEx >= l {
  7539  					return io.ErrUnexpectedEOF
  7540  				}
  7541  				b := dAtA[iNdEx]
  7542  				iNdEx++
  7543  				stringLen |= uint64(b&0x7F) << shift
  7544  				if b < 0x80 {
  7545  					break
  7546  				}
  7547  			}
  7548  			intStringLen := int(stringLen)
  7549  			if intStringLen < 0 {
  7550  				return ErrInvalidLength
  7551  			}
  7552  			postIndex := iNdEx + intStringLen
  7553  			if postIndex < 0 {
  7554  				return ErrInvalidLength
  7555  			}
  7556  			if postIndex > l {
  7557  				return io.ErrUnexpectedEOF
  7558  			}
  7559  			m.Payload = string(dAtA[iNdEx:postIndex])
  7560  			iNdEx = postIndex
  7561  		default:
  7562  			iNdEx = preIndex
  7563  			skippy, err := skip(dAtA[iNdEx:])
  7564  			if err != nil {
  7565  				return err
  7566  			}
  7567  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7568  				return ErrInvalidLength
  7569  			}
  7570  			if (iNdEx + skippy) > l {
  7571  				return io.ErrUnexpectedEOF
  7572  			}
  7573  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7574  			iNdEx += skippy
  7575  		}
  7576  	}
  7577  
  7578  	if iNdEx > l {
  7579  		return io.ErrUnexpectedEOF
  7580  	}
  7581  	return nil
  7582  }
  7583  func (m *PingResponse) UnmarshalVT(dAtA []byte) error {
  7584  	l := len(dAtA)
  7585  	iNdEx := 0
  7586  	for iNdEx < l {
  7587  		preIndex := iNdEx
  7588  		var wire uint64
  7589  		for shift := uint(0); ; shift += 7 {
  7590  			if shift >= 64 {
  7591  				return ErrIntOverflow
  7592  			}
  7593  			if iNdEx >= l {
  7594  				return io.ErrUnexpectedEOF
  7595  			}
  7596  			b := dAtA[iNdEx]
  7597  			iNdEx++
  7598  			wire |= uint64(b&0x7F) << shift
  7599  			if b < 0x80 {
  7600  				break
  7601  			}
  7602  		}
  7603  		fieldNum := int32(wire >> 3)
  7604  		wireType := int(wire & 0x7)
  7605  		if wireType == 4 {
  7606  			return fmt.Errorf("proto: PingResponse: wiretype end group for non-group")
  7607  		}
  7608  		if fieldNum <= 0 {
  7609  			return fmt.Errorf("proto: PingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  7610  		}
  7611  		switch fieldNum {
  7612  		case 1:
  7613  			if wireType != 2 {
  7614  				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
  7615  			}
  7616  			var stringLen uint64
  7617  			for shift := uint(0); ; shift += 7 {
  7618  				if shift >= 64 {
  7619  					return ErrIntOverflow
  7620  				}
  7621  				if iNdEx >= l {
  7622  					return io.ErrUnexpectedEOF
  7623  				}
  7624  				b := dAtA[iNdEx]
  7625  				iNdEx++
  7626  				stringLen |= uint64(b&0x7F) << shift
  7627  				if b < 0x80 {
  7628  					break
  7629  				}
  7630  			}
  7631  			intStringLen := int(stringLen)
  7632  			if intStringLen < 0 {
  7633  				return ErrInvalidLength
  7634  			}
  7635  			postIndex := iNdEx + intStringLen
  7636  			if postIndex < 0 {
  7637  				return ErrInvalidLength
  7638  			}
  7639  			if postIndex > l {
  7640  				return io.ErrUnexpectedEOF
  7641  			}
  7642  			m.Payload = string(dAtA[iNdEx:postIndex])
  7643  			iNdEx = postIndex
  7644  		default:
  7645  			iNdEx = preIndex
  7646  			skippy, err := skip(dAtA[iNdEx:])
  7647  			if err != nil {
  7648  				return err
  7649  			}
  7650  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7651  				return ErrInvalidLength
  7652  			}
  7653  			if (iNdEx + skippy) > l {
  7654  				return io.ErrUnexpectedEOF
  7655  			}
  7656  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7657  			iNdEx += skippy
  7658  		}
  7659  	}
  7660  
  7661  	if iNdEx > l {
  7662  		return io.ErrUnexpectedEOF
  7663  	}
  7664  	return nil
  7665  }
  7666  func (m *SleepRequest) UnmarshalVT(dAtA []byte) error {
  7667  	l := len(dAtA)
  7668  	iNdEx := 0
  7669  	for iNdEx < l {
  7670  		preIndex := iNdEx
  7671  		var wire uint64
  7672  		for shift := uint(0); ; shift += 7 {
  7673  			if shift >= 64 {
  7674  				return ErrIntOverflow
  7675  			}
  7676  			if iNdEx >= l {
  7677  				return io.ErrUnexpectedEOF
  7678  			}
  7679  			b := dAtA[iNdEx]
  7680  			iNdEx++
  7681  			wire |= uint64(b&0x7F) << shift
  7682  			if b < 0x80 {
  7683  				break
  7684  			}
  7685  		}
  7686  		fieldNum := int32(wire >> 3)
  7687  		wireType := int(wire & 0x7)
  7688  		if wireType == 4 {
  7689  			return fmt.Errorf("proto: SleepRequest: wiretype end group for non-group")
  7690  		}
  7691  		if fieldNum <= 0 {
  7692  			return fmt.Errorf("proto: SleepRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  7693  		}
  7694  		switch fieldNum {
  7695  		case 1:
  7696  			if wireType != 0 {
  7697  				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
  7698  			}
  7699  			m.Duration = 0
  7700  			for shift := uint(0); ; shift += 7 {
  7701  				if shift >= 64 {
  7702  					return ErrIntOverflow
  7703  				}
  7704  				if iNdEx >= l {
  7705  					return io.ErrUnexpectedEOF
  7706  				}
  7707  				b := dAtA[iNdEx]
  7708  				iNdEx++
  7709  				m.Duration |= int64(b&0x7F) << shift
  7710  				if b < 0x80 {
  7711  					break
  7712  				}
  7713  			}
  7714  		default:
  7715  			iNdEx = preIndex
  7716  			skippy, err := skip(dAtA[iNdEx:])
  7717  			if err != nil {
  7718  				return err
  7719  			}
  7720  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7721  				return ErrInvalidLength
  7722  			}
  7723  			if (iNdEx + skippy) > l {
  7724  				return io.ErrUnexpectedEOF
  7725  			}
  7726  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7727  			iNdEx += skippy
  7728  		}
  7729  	}
  7730  
  7731  	if iNdEx > l {
  7732  		return io.ErrUnexpectedEOF
  7733  	}
  7734  	return nil
  7735  }
  7736  func (m *SleepResponse) UnmarshalVT(dAtA []byte) error {
  7737  	l := len(dAtA)
  7738  	iNdEx := 0
  7739  	for iNdEx < l {
  7740  		preIndex := iNdEx
  7741  		var wire uint64
  7742  		for shift := uint(0); ; shift += 7 {
  7743  			if shift >= 64 {
  7744  				return ErrIntOverflow
  7745  			}
  7746  			if iNdEx >= l {
  7747  				return io.ErrUnexpectedEOF
  7748  			}
  7749  			b := dAtA[iNdEx]
  7750  			iNdEx++
  7751  			wire |= uint64(b&0x7F) << shift
  7752  			if b < 0x80 {
  7753  				break
  7754  			}
  7755  		}
  7756  		fieldNum := int32(wire >> 3)
  7757  		wireType := int(wire & 0x7)
  7758  		if wireType == 4 {
  7759  			return fmt.Errorf("proto: SleepResponse: wiretype end group for non-group")
  7760  		}
  7761  		if fieldNum <= 0 {
  7762  			return fmt.Errorf("proto: SleepResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  7763  		}
  7764  		switch fieldNum {
  7765  		default:
  7766  			iNdEx = preIndex
  7767  			skippy, err := skip(dAtA[iNdEx:])
  7768  			if err != nil {
  7769  				return err
  7770  			}
  7771  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7772  				return ErrInvalidLength
  7773  			}
  7774  			if (iNdEx + skippy) > l {
  7775  				return io.ErrUnexpectedEOF
  7776  			}
  7777  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  7778  			iNdEx += skippy
  7779  		}
  7780  	}
  7781  
  7782  	if iNdEx > l {
  7783  		return io.ErrUnexpectedEOF
  7784  	}
  7785  	return nil
  7786  }
  7787  func (m *ExecuteHookRequest) UnmarshalVT(dAtA []byte) error {
  7788  	l := len(dAtA)
  7789  	iNdEx := 0
  7790  	for iNdEx < l {
  7791  		preIndex := iNdEx
  7792  		var wire uint64
  7793  		for shift := uint(0); ; shift += 7 {
  7794  			if shift >= 64 {
  7795  				return ErrIntOverflow
  7796  			}
  7797  			if iNdEx >= l {
  7798  				return io.ErrUnexpectedEOF
  7799  			}
  7800  			b := dAtA[iNdEx]
  7801  			iNdEx++
  7802  			wire |= uint64(b&0x7F) << shift
  7803  			if b < 0x80 {
  7804  				break
  7805  			}
  7806  		}
  7807  		fieldNum := int32(wire >> 3)
  7808  		wireType := int(wire & 0x7)
  7809  		if wireType == 4 {
  7810  			return fmt.Errorf("proto: ExecuteHookRequest: wiretype end group for non-group")
  7811  		}
  7812  		if fieldNum <= 0 {
  7813  			return fmt.Errorf("proto: ExecuteHookRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  7814  		}
  7815  		switch fieldNum {
  7816  		case 1:
  7817  			if wireType != 2 {
  7818  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  7819  			}
  7820  			var stringLen uint64
  7821  			for shift := uint(0); ; shift += 7 {
  7822  				if shift >= 64 {
  7823  					return ErrIntOverflow
  7824  				}
  7825  				if iNdEx >= l {
  7826  					return io.ErrUnexpectedEOF
  7827  				}
  7828  				b := dAtA[iNdEx]
  7829  				iNdEx++
  7830  				stringLen |= uint64(b&0x7F) << shift
  7831  				if b < 0x80 {
  7832  					break
  7833  				}
  7834  			}
  7835  			intStringLen := int(stringLen)
  7836  			if intStringLen < 0 {
  7837  				return ErrInvalidLength
  7838  			}
  7839  			postIndex := iNdEx + intStringLen
  7840  			if postIndex < 0 {
  7841  				return ErrInvalidLength
  7842  			}
  7843  			if postIndex > l {
  7844  				return io.ErrUnexpectedEOF
  7845  			}
  7846  			m.Name = string(dAtA[iNdEx:postIndex])
  7847  			iNdEx = postIndex
  7848  		case 2:
  7849  			if wireType != 2 {
  7850  				return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
  7851  			}
  7852  			var stringLen uint64
  7853  			for shift := uint(0); ; shift += 7 {
  7854  				if shift >= 64 {
  7855  					return ErrIntOverflow
  7856  				}
  7857  				if iNdEx >= l {
  7858  					return io.ErrUnexpectedEOF
  7859  				}
  7860  				b := dAtA[iNdEx]
  7861  				iNdEx++
  7862  				stringLen |= uint64(b&0x7F) << shift
  7863  				if b < 0x80 {
  7864  					break
  7865  				}
  7866  			}
  7867  			intStringLen := int(stringLen)
  7868  			if intStringLen < 0 {
  7869  				return ErrInvalidLength
  7870  			}
  7871  			postIndex := iNdEx + intStringLen
  7872  			if postIndex < 0 {
  7873  				return ErrInvalidLength
  7874  			}
  7875  			if postIndex > l {
  7876  				return io.ErrUnexpectedEOF
  7877  			}
  7878  			m.Parameters = append(m.Parameters, string(dAtA[iNdEx:postIndex]))
  7879  			iNdEx = postIndex
  7880  		case 3:
  7881  			if wireType != 2 {
  7882  				return fmt.Errorf("proto: wrong wireType = %d for field ExtraEnv", wireType)
  7883  			}
  7884  			var msglen int
  7885  			for shift := uint(0); ; shift += 7 {
  7886  				if shift >= 64 {
  7887  					return ErrIntOverflow
  7888  				}
  7889  				if iNdEx >= l {
  7890  					return io.ErrUnexpectedEOF
  7891  				}
  7892  				b := dAtA[iNdEx]
  7893  				iNdEx++
  7894  				msglen |= int(b&0x7F) << shift
  7895  				if b < 0x80 {
  7896  					break
  7897  				}
  7898  			}
  7899  			if msglen < 0 {
  7900  				return ErrInvalidLength
  7901  			}
  7902  			postIndex := iNdEx + msglen
  7903  			if postIndex < 0 {
  7904  				return ErrInvalidLength
  7905  			}
  7906  			if postIndex > l {
  7907  				return io.ErrUnexpectedEOF
  7908  			}
  7909  			if m.ExtraEnv == nil {
  7910  				m.ExtraEnv = make(map[string]string)
  7911  			}
  7912  			var mapkey string
  7913  			var mapvalue string
  7914  			for iNdEx < postIndex {
  7915  				entryPreIndex := iNdEx
  7916  				var wire uint64
  7917  				for shift := uint(0); ; shift += 7 {
  7918  					if shift >= 64 {
  7919  						return ErrIntOverflow
  7920  					}
  7921  					if iNdEx >= l {
  7922  						return io.ErrUnexpectedEOF
  7923  					}
  7924  					b := dAtA[iNdEx]
  7925  					iNdEx++
  7926  					wire |= uint64(b&0x7F) << shift
  7927  					if b < 0x80 {
  7928  						break
  7929  					}
  7930  				}
  7931  				fieldNum := int32(wire >> 3)
  7932  				if fieldNum == 1 {
  7933  					var stringLenmapkey uint64
  7934  					for shift := uint(0); ; shift += 7 {
  7935  						if shift >= 64 {
  7936  							return ErrIntOverflow
  7937  						}
  7938  						if iNdEx >= l {
  7939  							return io.ErrUnexpectedEOF
  7940  						}
  7941  						b := dAtA[iNdEx]
  7942  						iNdEx++
  7943  						stringLenmapkey |= uint64(b&0x7F) << shift
  7944  						if b < 0x80 {
  7945  							break
  7946  						}
  7947  					}
  7948  					intStringLenmapkey := int(stringLenmapkey)
  7949  					if intStringLenmapkey < 0 {
  7950  						return ErrInvalidLength
  7951  					}
  7952  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  7953  					if postStringIndexmapkey < 0 {
  7954  						return ErrInvalidLength
  7955  					}
  7956  					if postStringIndexmapkey > l {
  7957  						return io.ErrUnexpectedEOF
  7958  					}
  7959  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  7960  					iNdEx = postStringIndexmapkey
  7961  				} else if fieldNum == 2 {
  7962  					var stringLenmapvalue uint64
  7963  					for shift := uint(0); ; shift += 7 {
  7964  						if shift >= 64 {
  7965  							return ErrIntOverflow
  7966  						}
  7967  						if iNdEx >= l {
  7968  							return io.ErrUnexpectedEOF
  7969  						}
  7970  						b := dAtA[iNdEx]
  7971  						iNdEx++
  7972  						stringLenmapvalue |= uint64(b&0x7F) << shift
  7973  						if b < 0x80 {
  7974  							break
  7975  						}
  7976  					}
  7977  					intStringLenmapvalue := int(stringLenmapvalue)
  7978  					if intStringLenmapvalue < 0 {
  7979  						return ErrInvalidLength
  7980  					}
  7981  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  7982  					if postStringIndexmapvalue < 0 {
  7983  						return ErrInvalidLength
  7984  					}
  7985  					if postStringIndexmapvalue > l {
  7986  						return io.ErrUnexpectedEOF
  7987  					}
  7988  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  7989  					iNdEx = postStringIndexmapvalue
  7990  				} else {
  7991  					iNdEx = entryPreIndex
  7992  					skippy, err := skip(dAtA[iNdEx:])
  7993  					if err != nil {
  7994  						return err
  7995  					}
  7996  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  7997  						return ErrInvalidLength
  7998  					}
  7999  					if (iNdEx + skippy) > postIndex {
  8000  						return io.ErrUnexpectedEOF
  8001  					}
  8002  					iNdEx += skippy
  8003  				}
  8004  			}
  8005  			m.ExtraEnv[mapkey] = mapvalue
  8006  			iNdEx = postIndex
  8007  		default:
  8008  			iNdEx = preIndex
  8009  			skippy, err := skip(dAtA[iNdEx:])
  8010  			if err != nil {
  8011  				return err
  8012  			}
  8013  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8014  				return ErrInvalidLength
  8015  			}
  8016  			if (iNdEx + skippy) > l {
  8017  				return io.ErrUnexpectedEOF
  8018  			}
  8019  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8020  			iNdEx += skippy
  8021  		}
  8022  	}
  8023  
  8024  	if iNdEx > l {
  8025  		return io.ErrUnexpectedEOF
  8026  	}
  8027  	return nil
  8028  }
  8029  func (m *ExecuteHookResponse) UnmarshalVT(dAtA []byte) error {
  8030  	l := len(dAtA)
  8031  	iNdEx := 0
  8032  	for iNdEx < l {
  8033  		preIndex := iNdEx
  8034  		var wire uint64
  8035  		for shift := uint(0); ; shift += 7 {
  8036  			if shift >= 64 {
  8037  				return ErrIntOverflow
  8038  			}
  8039  			if iNdEx >= l {
  8040  				return io.ErrUnexpectedEOF
  8041  			}
  8042  			b := dAtA[iNdEx]
  8043  			iNdEx++
  8044  			wire |= uint64(b&0x7F) << shift
  8045  			if b < 0x80 {
  8046  				break
  8047  			}
  8048  		}
  8049  		fieldNum := int32(wire >> 3)
  8050  		wireType := int(wire & 0x7)
  8051  		if wireType == 4 {
  8052  			return fmt.Errorf("proto: ExecuteHookResponse: wiretype end group for non-group")
  8053  		}
  8054  		if fieldNum <= 0 {
  8055  			return fmt.Errorf("proto: ExecuteHookResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8056  		}
  8057  		switch fieldNum {
  8058  		case 1:
  8059  			if wireType != 0 {
  8060  				return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
  8061  			}
  8062  			m.ExitStatus = 0
  8063  			for shift := uint(0); ; shift += 7 {
  8064  				if shift >= 64 {
  8065  					return ErrIntOverflow
  8066  				}
  8067  				if iNdEx >= l {
  8068  					return io.ErrUnexpectedEOF
  8069  				}
  8070  				b := dAtA[iNdEx]
  8071  				iNdEx++
  8072  				m.ExitStatus |= int64(b&0x7F) << shift
  8073  				if b < 0x80 {
  8074  					break
  8075  				}
  8076  			}
  8077  		case 2:
  8078  			if wireType != 2 {
  8079  				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
  8080  			}
  8081  			var stringLen uint64
  8082  			for shift := uint(0); ; shift += 7 {
  8083  				if shift >= 64 {
  8084  					return ErrIntOverflow
  8085  				}
  8086  				if iNdEx >= l {
  8087  					return io.ErrUnexpectedEOF
  8088  				}
  8089  				b := dAtA[iNdEx]
  8090  				iNdEx++
  8091  				stringLen |= uint64(b&0x7F) << shift
  8092  				if b < 0x80 {
  8093  					break
  8094  				}
  8095  			}
  8096  			intStringLen := int(stringLen)
  8097  			if intStringLen < 0 {
  8098  				return ErrInvalidLength
  8099  			}
  8100  			postIndex := iNdEx + intStringLen
  8101  			if postIndex < 0 {
  8102  				return ErrInvalidLength
  8103  			}
  8104  			if postIndex > l {
  8105  				return io.ErrUnexpectedEOF
  8106  			}
  8107  			m.Stdout = string(dAtA[iNdEx:postIndex])
  8108  			iNdEx = postIndex
  8109  		case 3:
  8110  			if wireType != 2 {
  8111  				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
  8112  			}
  8113  			var stringLen uint64
  8114  			for shift := uint(0); ; shift += 7 {
  8115  				if shift >= 64 {
  8116  					return ErrIntOverflow
  8117  				}
  8118  				if iNdEx >= l {
  8119  					return io.ErrUnexpectedEOF
  8120  				}
  8121  				b := dAtA[iNdEx]
  8122  				iNdEx++
  8123  				stringLen |= uint64(b&0x7F) << shift
  8124  				if b < 0x80 {
  8125  					break
  8126  				}
  8127  			}
  8128  			intStringLen := int(stringLen)
  8129  			if intStringLen < 0 {
  8130  				return ErrInvalidLength
  8131  			}
  8132  			postIndex := iNdEx + intStringLen
  8133  			if postIndex < 0 {
  8134  				return ErrInvalidLength
  8135  			}
  8136  			if postIndex > l {
  8137  				return io.ErrUnexpectedEOF
  8138  			}
  8139  			m.Stderr = string(dAtA[iNdEx:postIndex])
  8140  			iNdEx = postIndex
  8141  		default:
  8142  			iNdEx = preIndex
  8143  			skippy, err := skip(dAtA[iNdEx:])
  8144  			if err != nil {
  8145  				return err
  8146  			}
  8147  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8148  				return ErrInvalidLength
  8149  			}
  8150  			if (iNdEx + skippy) > l {
  8151  				return io.ErrUnexpectedEOF
  8152  			}
  8153  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8154  			iNdEx += skippy
  8155  		}
  8156  	}
  8157  
  8158  	if iNdEx > l {
  8159  		return io.ErrUnexpectedEOF
  8160  	}
  8161  	return nil
  8162  }
  8163  func (m *GetSchemaRequest) UnmarshalVT(dAtA []byte) error {
  8164  	l := len(dAtA)
  8165  	iNdEx := 0
  8166  	for iNdEx < l {
  8167  		preIndex := iNdEx
  8168  		var wire uint64
  8169  		for shift := uint(0); ; shift += 7 {
  8170  			if shift >= 64 {
  8171  				return ErrIntOverflow
  8172  			}
  8173  			if iNdEx >= l {
  8174  				return io.ErrUnexpectedEOF
  8175  			}
  8176  			b := dAtA[iNdEx]
  8177  			iNdEx++
  8178  			wire |= uint64(b&0x7F) << shift
  8179  			if b < 0x80 {
  8180  				break
  8181  			}
  8182  		}
  8183  		fieldNum := int32(wire >> 3)
  8184  		wireType := int(wire & 0x7)
  8185  		if wireType == 4 {
  8186  			return fmt.Errorf("proto: GetSchemaRequest: wiretype end group for non-group")
  8187  		}
  8188  		if fieldNum <= 0 {
  8189  			return fmt.Errorf("proto: GetSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8190  		}
  8191  		switch fieldNum {
  8192  		case 1:
  8193  			if wireType != 2 {
  8194  				return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType)
  8195  			}
  8196  			var stringLen uint64
  8197  			for shift := uint(0); ; shift += 7 {
  8198  				if shift >= 64 {
  8199  					return ErrIntOverflow
  8200  				}
  8201  				if iNdEx >= l {
  8202  					return io.ErrUnexpectedEOF
  8203  				}
  8204  				b := dAtA[iNdEx]
  8205  				iNdEx++
  8206  				stringLen |= uint64(b&0x7F) << shift
  8207  				if b < 0x80 {
  8208  					break
  8209  				}
  8210  			}
  8211  			intStringLen := int(stringLen)
  8212  			if intStringLen < 0 {
  8213  				return ErrInvalidLength
  8214  			}
  8215  			postIndex := iNdEx + intStringLen
  8216  			if postIndex < 0 {
  8217  				return ErrInvalidLength
  8218  			}
  8219  			if postIndex > l {
  8220  				return io.ErrUnexpectedEOF
  8221  			}
  8222  			m.Tables = append(m.Tables, string(dAtA[iNdEx:postIndex]))
  8223  			iNdEx = postIndex
  8224  		case 2:
  8225  			if wireType != 0 {
  8226  				return fmt.Errorf("proto: wrong wireType = %d for field IncludeViews", wireType)
  8227  			}
  8228  			var v int
  8229  			for shift := uint(0); ; shift += 7 {
  8230  				if shift >= 64 {
  8231  					return ErrIntOverflow
  8232  				}
  8233  				if iNdEx >= l {
  8234  					return io.ErrUnexpectedEOF
  8235  				}
  8236  				b := dAtA[iNdEx]
  8237  				iNdEx++
  8238  				v |= int(b&0x7F) << shift
  8239  				if b < 0x80 {
  8240  					break
  8241  				}
  8242  			}
  8243  			m.IncludeViews = bool(v != 0)
  8244  		case 3:
  8245  			if wireType != 2 {
  8246  				return fmt.Errorf("proto: wrong wireType = %d for field ExcludeTables", wireType)
  8247  			}
  8248  			var stringLen uint64
  8249  			for shift := uint(0); ; shift += 7 {
  8250  				if shift >= 64 {
  8251  					return ErrIntOverflow
  8252  				}
  8253  				if iNdEx >= l {
  8254  					return io.ErrUnexpectedEOF
  8255  				}
  8256  				b := dAtA[iNdEx]
  8257  				iNdEx++
  8258  				stringLen |= uint64(b&0x7F) << shift
  8259  				if b < 0x80 {
  8260  					break
  8261  				}
  8262  			}
  8263  			intStringLen := int(stringLen)
  8264  			if intStringLen < 0 {
  8265  				return ErrInvalidLength
  8266  			}
  8267  			postIndex := iNdEx + intStringLen
  8268  			if postIndex < 0 {
  8269  				return ErrInvalidLength
  8270  			}
  8271  			if postIndex > l {
  8272  				return io.ErrUnexpectedEOF
  8273  			}
  8274  			m.ExcludeTables = append(m.ExcludeTables, string(dAtA[iNdEx:postIndex]))
  8275  			iNdEx = postIndex
  8276  		case 4:
  8277  			if wireType != 0 {
  8278  				return fmt.Errorf("proto: wrong wireType = %d for field TableSchemaOnly", wireType)
  8279  			}
  8280  			var v int
  8281  			for shift := uint(0); ; shift += 7 {
  8282  				if shift >= 64 {
  8283  					return ErrIntOverflow
  8284  				}
  8285  				if iNdEx >= l {
  8286  					return io.ErrUnexpectedEOF
  8287  				}
  8288  				b := dAtA[iNdEx]
  8289  				iNdEx++
  8290  				v |= int(b&0x7F) << shift
  8291  				if b < 0x80 {
  8292  					break
  8293  				}
  8294  			}
  8295  			m.TableSchemaOnly = bool(v != 0)
  8296  		default:
  8297  			iNdEx = preIndex
  8298  			skippy, err := skip(dAtA[iNdEx:])
  8299  			if err != nil {
  8300  				return err
  8301  			}
  8302  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8303  				return ErrInvalidLength
  8304  			}
  8305  			if (iNdEx + skippy) > l {
  8306  				return io.ErrUnexpectedEOF
  8307  			}
  8308  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8309  			iNdEx += skippy
  8310  		}
  8311  	}
  8312  
  8313  	if iNdEx > l {
  8314  		return io.ErrUnexpectedEOF
  8315  	}
  8316  	return nil
  8317  }
  8318  func (m *GetSchemaResponse) UnmarshalVT(dAtA []byte) error {
  8319  	l := len(dAtA)
  8320  	iNdEx := 0
  8321  	for iNdEx < l {
  8322  		preIndex := iNdEx
  8323  		var wire uint64
  8324  		for shift := uint(0); ; shift += 7 {
  8325  			if shift >= 64 {
  8326  				return ErrIntOverflow
  8327  			}
  8328  			if iNdEx >= l {
  8329  				return io.ErrUnexpectedEOF
  8330  			}
  8331  			b := dAtA[iNdEx]
  8332  			iNdEx++
  8333  			wire |= uint64(b&0x7F) << shift
  8334  			if b < 0x80 {
  8335  				break
  8336  			}
  8337  		}
  8338  		fieldNum := int32(wire >> 3)
  8339  		wireType := int(wire & 0x7)
  8340  		if wireType == 4 {
  8341  			return fmt.Errorf("proto: GetSchemaResponse: wiretype end group for non-group")
  8342  		}
  8343  		if fieldNum <= 0 {
  8344  			return fmt.Errorf("proto: GetSchemaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8345  		}
  8346  		switch fieldNum {
  8347  		case 1:
  8348  			if wireType != 2 {
  8349  				return fmt.Errorf("proto: wrong wireType = %d for field SchemaDefinition", wireType)
  8350  			}
  8351  			var msglen int
  8352  			for shift := uint(0); ; shift += 7 {
  8353  				if shift >= 64 {
  8354  					return ErrIntOverflow
  8355  				}
  8356  				if iNdEx >= l {
  8357  					return io.ErrUnexpectedEOF
  8358  				}
  8359  				b := dAtA[iNdEx]
  8360  				iNdEx++
  8361  				msglen |= int(b&0x7F) << shift
  8362  				if b < 0x80 {
  8363  					break
  8364  				}
  8365  			}
  8366  			if msglen < 0 {
  8367  				return ErrInvalidLength
  8368  			}
  8369  			postIndex := iNdEx + msglen
  8370  			if postIndex < 0 {
  8371  				return ErrInvalidLength
  8372  			}
  8373  			if postIndex > l {
  8374  				return io.ErrUnexpectedEOF
  8375  			}
  8376  			if m.SchemaDefinition == nil {
  8377  				m.SchemaDefinition = &SchemaDefinition{}
  8378  			}
  8379  			if err := m.SchemaDefinition.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8380  				return err
  8381  			}
  8382  			iNdEx = postIndex
  8383  		default:
  8384  			iNdEx = preIndex
  8385  			skippy, err := skip(dAtA[iNdEx:])
  8386  			if err != nil {
  8387  				return err
  8388  			}
  8389  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8390  				return ErrInvalidLength
  8391  			}
  8392  			if (iNdEx + skippy) > l {
  8393  				return io.ErrUnexpectedEOF
  8394  			}
  8395  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8396  			iNdEx += skippy
  8397  		}
  8398  	}
  8399  
  8400  	if iNdEx > l {
  8401  		return io.ErrUnexpectedEOF
  8402  	}
  8403  	return nil
  8404  }
  8405  func (m *GetPermissionsRequest) UnmarshalVT(dAtA []byte) error {
  8406  	l := len(dAtA)
  8407  	iNdEx := 0
  8408  	for iNdEx < l {
  8409  		preIndex := iNdEx
  8410  		var wire uint64
  8411  		for shift := uint(0); ; shift += 7 {
  8412  			if shift >= 64 {
  8413  				return ErrIntOverflow
  8414  			}
  8415  			if iNdEx >= l {
  8416  				return io.ErrUnexpectedEOF
  8417  			}
  8418  			b := dAtA[iNdEx]
  8419  			iNdEx++
  8420  			wire |= uint64(b&0x7F) << shift
  8421  			if b < 0x80 {
  8422  				break
  8423  			}
  8424  		}
  8425  		fieldNum := int32(wire >> 3)
  8426  		wireType := int(wire & 0x7)
  8427  		if wireType == 4 {
  8428  			return fmt.Errorf("proto: GetPermissionsRequest: wiretype end group for non-group")
  8429  		}
  8430  		if fieldNum <= 0 {
  8431  			return fmt.Errorf("proto: GetPermissionsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8432  		}
  8433  		switch fieldNum {
  8434  		default:
  8435  			iNdEx = preIndex
  8436  			skippy, err := skip(dAtA[iNdEx:])
  8437  			if err != nil {
  8438  				return err
  8439  			}
  8440  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8441  				return ErrInvalidLength
  8442  			}
  8443  			if (iNdEx + skippy) > l {
  8444  				return io.ErrUnexpectedEOF
  8445  			}
  8446  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8447  			iNdEx += skippy
  8448  		}
  8449  	}
  8450  
  8451  	if iNdEx > l {
  8452  		return io.ErrUnexpectedEOF
  8453  	}
  8454  	return nil
  8455  }
  8456  func (m *GetPermissionsResponse) UnmarshalVT(dAtA []byte) error {
  8457  	l := len(dAtA)
  8458  	iNdEx := 0
  8459  	for iNdEx < l {
  8460  		preIndex := iNdEx
  8461  		var wire uint64
  8462  		for shift := uint(0); ; shift += 7 {
  8463  			if shift >= 64 {
  8464  				return ErrIntOverflow
  8465  			}
  8466  			if iNdEx >= l {
  8467  				return io.ErrUnexpectedEOF
  8468  			}
  8469  			b := dAtA[iNdEx]
  8470  			iNdEx++
  8471  			wire |= uint64(b&0x7F) << shift
  8472  			if b < 0x80 {
  8473  				break
  8474  			}
  8475  		}
  8476  		fieldNum := int32(wire >> 3)
  8477  		wireType := int(wire & 0x7)
  8478  		if wireType == 4 {
  8479  			return fmt.Errorf("proto: GetPermissionsResponse: wiretype end group for non-group")
  8480  		}
  8481  		if fieldNum <= 0 {
  8482  			return fmt.Errorf("proto: GetPermissionsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8483  		}
  8484  		switch fieldNum {
  8485  		case 1:
  8486  			if wireType != 2 {
  8487  				return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
  8488  			}
  8489  			var msglen int
  8490  			for shift := uint(0); ; shift += 7 {
  8491  				if shift >= 64 {
  8492  					return ErrIntOverflow
  8493  				}
  8494  				if iNdEx >= l {
  8495  					return io.ErrUnexpectedEOF
  8496  				}
  8497  				b := dAtA[iNdEx]
  8498  				iNdEx++
  8499  				msglen |= int(b&0x7F) << shift
  8500  				if b < 0x80 {
  8501  					break
  8502  				}
  8503  			}
  8504  			if msglen < 0 {
  8505  				return ErrInvalidLength
  8506  			}
  8507  			postIndex := iNdEx + msglen
  8508  			if postIndex < 0 {
  8509  				return ErrInvalidLength
  8510  			}
  8511  			if postIndex > l {
  8512  				return io.ErrUnexpectedEOF
  8513  			}
  8514  			if m.Permissions == nil {
  8515  				m.Permissions = &Permissions{}
  8516  			}
  8517  			if err := m.Permissions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  8518  				return err
  8519  			}
  8520  			iNdEx = postIndex
  8521  		default:
  8522  			iNdEx = preIndex
  8523  			skippy, err := skip(dAtA[iNdEx:])
  8524  			if err != nil {
  8525  				return err
  8526  			}
  8527  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8528  				return ErrInvalidLength
  8529  			}
  8530  			if (iNdEx + skippy) > l {
  8531  				return io.ErrUnexpectedEOF
  8532  			}
  8533  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8534  			iNdEx += skippy
  8535  		}
  8536  	}
  8537  
  8538  	if iNdEx > l {
  8539  		return io.ErrUnexpectedEOF
  8540  	}
  8541  	return nil
  8542  }
  8543  func (m *SetReadOnlyRequest) UnmarshalVT(dAtA []byte) error {
  8544  	l := len(dAtA)
  8545  	iNdEx := 0
  8546  	for iNdEx < l {
  8547  		preIndex := iNdEx
  8548  		var wire uint64
  8549  		for shift := uint(0); ; shift += 7 {
  8550  			if shift >= 64 {
  8551  				return ErrIntOverflow
  8552  			}
  8553  			if iNdEx >= l {
  8554  				return io.ErrUnexpectedEOF
  8555  			}
  8556  			b := dAtA[iNdEx]
  8557  			iNdEx++
  8558  			wire |= uint64(b&0x7F) << shift
  8559  			if b < 0x80 {
  8560  				break
  8561  			}
  8562  		}
  8563  		fieldNum := int32(wire >> 3)
  8564  		wireType := int(wire & 0x7)
  8565  		if wireType == 4 {
  8566  			return fmt.Errorf("proto: SetReadOnlyRequest: wiretype end group for non-group")
  8567  		}
  8568  		if fieldNum <= 0 {
  8569  			return fmt.Errorf("proto: SetReadOnlyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8570  		}
  8571  		switch fieldNum {
  8572  		default:
  8573  			iNdEx = preIndex
  8574  			skippy, err := skip(dAtA[iNdEx:])
  8575  			if err != nil {
  8576  				return err
  8577  			}
  8578  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8579  				return ErrInvalidLength
  8580  			}
  8581  			if (iNdEx + skippy) > l {
  8582  				return io.ErrUnexpectedEOF
  8583  			}
  8584  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8585  			iNdEx += skippy
  8586  		}
  8587  	}
  8588  
  8589  	if iNdEx > l {
  8590  		return io.ErrUnexpectedEOF
  8591  	}
  8592  	return nil
  8593  }
  8594  func (m *SetReadOnlyResponse) UnmarshalVT(dAtA []byte) error {
  8595  	l := len(dAtA)
  8596  	iNdEx := 0
  8597  	for iNdEx < l {
  8598  		preIndex := iNdEx
  8599  		var wire uint64
  8600  		for shift := uint(0); ; shift += 7 {
  8601  			if shift >= 64 {
  8602  				return ErrIntOverflow
  8603  			}
  8604  			if iNdEx >= l {
  8605  				return io.ErrUnexpectedEOF
  8606  			}
  8607  			b := dAtA[iNdEx]
  8608  			iNdEx++
  8609  			wire |= uint64(b&0x7F) << shift
  8610  			if b < 0x80 {
  8611  				break
  8612  			}
  8613  		}
  8614  		fieldNum := int32(wire >> 3)
  8615  		wireType := int(wire & 0x7)
  8616  		if wireType == 4 {
  8617  			return fmt.Errorf("proto: SetReadOnlyResponse: wiretype end group for non-group")
  8618  		}
  8619  		if fieldNum <= 0 {
  8620  			return fmt.Errorf("proto: SetReadOnlyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8621  		}
  8622  		switch fieldNum {
  8623  		default:
  8624  			iNdEx = preIndex
  8625  			skippy, err := skip(dAtA[iNdEx:])
  8626  			if err != nil {
  8627  				return err
  8628  			}
  8629  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8630  				return ErrInvalidLength
  8631  			}
  8632  			if (iNdEx + skippy) > l {
  8633  				return io.ErrUnexpectedEOF
  8634  			}
  8635  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8636  			iNdEx += skippy
  8637  		}
  8638  	}
  8639  
  8640  	if iNdEx > l {
  8641  		return io.ErrUnexpectedEOF
  8642  	}
  8643  	return nil
  8644  }
  8645  func (m *SetReadWriteRequest) UnmarshalVT(dAtA []byte) error {
  8646  	l := len(dAtA)
  8647  	iNdEx := 0
  8648  	for iNdEx < l {
  8649  		preIndex := iNdEx
  8650  		var wire uint64
  8651  		for shift := uint(0); ; shift += 7 {
  8652  			if shift >= 64 {
  8653  				return ErrIntOverflow
  8654  			}
  8655  			if iNdEx >= l {
  8656  				return io.ErrUnexpectedEOF
  8657  			}
  8658  			b := dAtA[iNdEx]
  8659  			iNdEx++
  8660  			wire |= uint64(b&0x7F) << shift
  8661  			if b < 0x80 {
  8662  				break
  8663  			}
  8664  		}
  8665  		fieldNum := int32(wire >> 3)
  8666  		wireType := int(wire & 0x7)
  8667  		if wireType == 4 {
  8668  			return fmt.Errorf("proto: SetReadWriteRequest: wiretype end group for non-group")
  8669  		}
  8670  		if fieldNum <= 0 {
  8671  			return fmt.Errorf("proto: SetReadWriteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8672  		}
  8673  		switch fieldNum {
  8674  		default:
  8675  			iNdEx = preIndex
  8676  			skippy, err := skip(dAtA[iNdEx:])
  8677  			if err != nil {
  8678  				return err
  8679  			}
  8680  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8681  				return ErrInvalidLength
  8682  			}
  8683  			if (iNdEx + skippy) > l {
  8684  				return io.ErrUnexpectedEOF
  8685  			}
  8686  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8687  			iNdEx += skippy
  8688  		}
  8689  	}
  8690  
  8691  	if iNdEx > l {
  8692  		return io.ErrUnexpectedEOF
  8693  	}
  8694  	return nil
  8695  }
  8696  func (m *SetReadWriteResponse) UnmarshalVT(dAtA []byte) error {
  8697  	l := len(dAtA)
  8698  	iNdEx := 0
  8699  	for iNdEx < l {
  8700  		preIndex := iNdEx
  8701  		var wire uint64
  8702  		for shift := uint(0); ; shift += 7 {
  8703  			if shift >= 64 {
  8704  				return ErrIntOverflow
  8705  			}
  8706  			if iNdEx >= l {
  8707  				return io.ErrUnexpectedEOF
  8708  			}
  8709  			b := dAtA[iNdEx]
  8710  			iNdEx++
  8711  			wire |= uint64(b&0x7F) << shift
  8712  			if b < 0x80 {
  8713  				break
  8714  			}
  8715  		}
  8716  		fieldNum := int32(wire >> 3)
  8717  		wireType := int(wire & 0x7)
  8718  		if wireType == 4 {
  8719  			return fmt.Errorf("proto: SetReadWriteResponse: wiretype end group for non-group")
  8720  		}
  8721  		if fieldNum <= 0 {
  8722  			return fmt.Errorf("proto: SetReadWriteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8723  		}
  8724  		switch fieldNum {
  8725  		default:
  8726  			iNdEx = preIndex
  8727  			skippy, err := skip(dAtA[iNdEx:])
  8728  			if err != nil {
  8729  				return err
  8730  			}
  8731  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8732  				return ErrInvalidLength
  8733  			}
  8734  			if (iNdEx + skippy) > l {
  8735  				return io.ErrUnexpectedEOF
  8736  			}
  8737  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8738  			iNdEx += skippy
  8739  		}
  8740  	}
  8741  
  8742  	if iNdEx > l {
  8743  		return io.ErrUnexpectedEOF
  8744  	}
  8745  	return nil
  8746  }
  8747  func (m *ChangeTypeRequest) UnmarshalVT(dAtA []byte) error {
  8748  	l := len(dAtA)
  8749  	iNdEx := 0
  8750  	for iNdEx < l {
  8751  		preIndex := iNdEx
  8752  		var wire uint64
  8753  		for shift := uint(0); ; shift += 7 {
  8754  			if shift >= 64 {
  8755  				return ErrIntOverflow
  8756  			}
  8757  			if iNdEx >= l {
  8758  				return io.ErrUnexpectedEOF
  8759  			}
  8760  			b := dAtA[iNdEx]
  8761  			iNdEx++
  8762  			wire |= uint64(b&0x7F) << shift
  8763  			if b < 0x80 {
  8764  				break
  8765  			}
  8766  		}
  8767  		fieldNum := int32(wire >> 3)
  8768  		wireType := int(wire & 0x7)
  8769  		if wireType == 4 {
  8770  			return fmt.Errorf("proto: ChangeTypeRequest: wiretype end group for non-group")
  8771  		}
  8772  		if fieldNum <= 0 {
  8773  			return fmt.Errorf("proto: ChangeTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8774  		}
  8775  		switch fieldNum {
  8776  		case 1:
  8777  			if wireType != 0 {
  8778  				return fmt.Errorf("proto: wrong wireType = %d for field TabletType", wireType)
  8779  			}
  8780  			m.TabletType = 0
  8781  			for shift := uint(0); ; shift += 7 {
  8782  				if shift >= 64 {
  8783  					return ErrIntOverflow
  8784  				}
  8785  				if iNdEx >= l {
  8786  					return io.ErrUnexpectedEOF
  8787  				}
  8788  				b := dAtA[iNdEx]
  8789  				iNdEx++
  8790  				m.TabletType |= topodata.TabletType(b&0x7F) << shift
  8791  				if b < 0x80 {
  8792  					break
  8793  				}
  8794  			}
  8795  		case 2:
  8796  			if wireType != 0 {
  8797  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
  8798  			}
  8799  			var v int
  8800  			for shift := uint(0); ; shift += 7 {
  8801  				if shift >= 64 {
  8802  					return ErrIntOverflow
  8803  				}
  8804  				if iNdEx >= l {
  8805  					return io.ErrUnexpectedEOF
  8806  				}
  8807  				b := dAtA[iNdEx]
  8808  				iNdEx++
  8809  				v |= int(b&0x7F) << shift
  8810  				if b < 0x80 {
  8811  					break
  8812  				}
  8813  			}
  8814  			m.SemiSync = bool(v != 0)
  8815  		default:
  8816  			iNdEx = preIndex
  8817  			skippy, err := skip(dAtA[iNdEx:])
  8818  			if err != nil {
  8819  				return err
  8820  			}
  8821  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8822  				return ErrInvalidLength
  8823  			}
  8824  			if (iNdEx + skippy) > l {
  8825  				return io.ErrUnexpectedEOF
  8826  			}
  8827  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8828  			iNdEx += skippy
  8829  		}
  8830  	}
  8831  
  8832  	if iNdEx > l {
  8833  		return io.ErrUnexpectedEOF
  8834  	}
  8835  	return nil
  8836  }
  8837  func (m *ChangeTypeResponse) UnmarshalVT(dAtA []byte) error {
  8838  	l := len(dAtA)
  8839  	iNdEx := 0
  8840  	for iNdEx < l {
  8841  		preIndex := iNdEx
  8842  		var wire uint64
  8843  		for shift := uint(0); ; shift += 7 {
  8844  			if shift >= 64 {
  8845  				return ErrIntOverflow
  8846  			}
  8847  			if iNdEx >= l {
  8848  				return io.ErrUnexpectedEOF
  8849  			}
  8850  			b := dAtA[iNdEx]
  8851  			iNdEx++
  8852  			wire |= uint64(b&0x7F) << shift
  8853  			if b < 0x80 {
  8854  				break
  8855  			}
  8856  		}
  8857  		fieldNum := int32(wire >> 3)
  8858  		wireType := int(wire & 0x7)
  8859  		if wireType == 4 {
  8860  			return fmt.Errorf("proto: ChangeTypeResponse: wiretype end group for non-group")
  8861  		}
  8862  		if fieldNum <= 0 {
  8863  			return fmt.Errorf("proto: ChangeTypeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8864  		}
  8865  		switch fieldNum {
  8866  		default:
  8867  			iNdEx = preIndex
  8868  			skippy, err := skip(dAtA[iNdEx:])
  8869  			if err != nil {
  8870  				return err
  8871  			}
  8872  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8873  				return ErrInvalidLength
  8874  			}
  8875  			if (iNdEx + skippy) > l {
  8876  				return io.ErrUnexpectedEOF
  8877  			}
  8878  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8879  			iNdEx += skippy
  8880  		}
  8881  	}
  8882  
  8883  	if iNdEx > l {
  8884  		return io.ErrUnexpectedEOF
  8885  	}
  8886  	return nil
  8887  }
  8888  func (m *RefreshStateRequest) UnmarshalVT(dAtA []byte) error {
  8889  	l := len(dAtA)
  8890  	iNdEx := 0
  8891  	for iNdEx < l {
  8892  		preIndex := iNdEx
  8893  		var wire uint64
  8894  		for shift := uint(0); ; shift += 7 {
  8895  			if shift >= 64 {
  8896  				return ErrIntOverflow
  8897  			}
  8898  			if iNdEx >= l {
  8899  				return io.ErrUnexpectedEOF
  8900  			}
  8901  			b := dAtA[iNdEx]
  8902  			iNdEx++
  8903  			wire |= uint64(b&0x7F) << shift
  8904  			if b < 0x80 {
  8905  				break
  8906  			}
  8907  		}
  8908  		fieldNum := int32(wire >> 3)
  8909  		wireType := int(wire & 0x7)
  8910  		if wireType == 4 {
  8911  			return fmt.Errorf("proto: RefreshStateRequest: wiretype end group for non-group")
  8912  		}
  8913  		if fieldNum <= 0 {
  8914  			return fmt.Errorf("proto: RefreshStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  8915  		}
  8916  		switch fieldNum {
  8917  		default:
  8918  			iNdEx = preIndex
  8919  			skippy, err := skip(dAtA[iNdEx:])
  8920  			if err != nil {
  8921  				return err
  8922  			}
  8923  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8924  				return ErrInvalidLength
  8925  			}
  8926  			if (iNdEx + skippy) > l {
  8927  				return io.ErrUnexpectedEOF
  8928  			}
  8929  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8930  			iNdEx += skippy
  8931  		}
  8932  	}
  8933  
  8934  	if iNdEx > l {
  8935  		return io.ErrUnexpectedEOF
  8936  	}
  8937  	return nil
  8938  }
  8939  func (m *RefreshStateResponse) UnmarshalVT(dAtA []byte) error {
  8940  	l := len(dAtA)
  8941  	iNdEx := 0
  8942  	for iNdEx < l {
  8943  		preIndex := iNdEx
  8944  		var wire uint64
  8945  		for shift := uint(0); ; shift += 7 {
  8946  			if shift >= 64 {
  8947  				return ErrIntOverflow
  8948  			}
  8949  			if iNdEx >= l {
  8950  				return io.ErrUnexpectedEOF
  8951  			}
  8952  			b := dAtA[iNdEx]
  8953  			iNdEx++
  8954  			wire |= uint64(b&0x7F) << shift
  8955  			if b < 0x80 {
  8956  				break
  8957  			}
  8958  		}
  8959  		fieldNum := int32(wire >> 3)
  8960  		wireType := int(wire & 0x7)
  8961  		if wireType == 4 {
  8962  			return fmt.Errorf("proto: RefreshStateResponse: wiretype end group for non-group")
  8963  		}
  8964  		if fieldNum <= 0 {
  8965  			return fmt.Errorf("proto: RefreshStateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  8966  		}
  8967  		switch fieldNum {
  8968  		default:
  8969  			iNdEx = preIndex
  8970  			skippy, err := skip(dAtA[iNdEx:])
  8971  			if err != nil {
  8972  				return err
  8973  			}
  8974  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8975  				return ErrInvalidLength
  8976  			}
  8977  			if (iNdEx + skippy) > l {
  8978  				return io.ErrUnexpectedEOF
  8979  			}
  8980  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  8981  			iNdEx += skippy
  8982  		}
  8983  	}
  8984  
  8985  	if iNdEx > l {
  8986  		return io.ErrUnexpectedEOF
  8987  	}
  8988  	return nil
  8989  }
  8990  func (m *RunHealthCheckRequest) UnmarshalVT(dAtA []byte) error {
  8991  	l := len(dAtA)
  8992  	iNdEx := 0
  8993  	for iNdEx < l {
  8994  		preIndex := iNdEx
  8995  		var wire uint64
  8996  		for shift := uint(0); ; shift += 7 {
  8997  			if shift >= 64 {
  8998  				return ErrIntOverflow
  8999  			}
  9000  			if iNdEx >= l {
  9001  				return io.ErrUnexpectedEOF
  9002  			}
  9003  			b := dAtA[iNdEx]
  9004  			iNdEx++
  9005  			wire |= uint64(b&0x7F) << shift
  9006  			if b < 0x80 {
  9007  				break
  9008  			}
  9009  		}
  9010  		fieldNum := int32(wire >> 3)
  9011  		wireType := int(wire & 0x7)
  9012  		if wireType == 4 {
  9013  			return fmt.Errorf("proto: RunHealthCheckRequest: wiretype end group for non-group")
  9014  		}
  9015  		if fieldNum <= 0 {
  9016  			return fmt.Errorf("proto: RunHealthCheckRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9017  		}
  9018  		switch fieldNum {
  9019  		default:
  9020  			iNdEx = preIndex
  9021  			skippy, err := skip(dAtA[iNdEx:])
  9022  			if err != nil {
  9023  				return err
  9024  			}
  9025  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9026  				return ErrInvalidLength
  9027  			}
  9028  			if (iNdEx + skippy) > l {
  9029  				return io.ErrUnexpectedEOF
  9030  			}
  9031  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9032  			iNdEx += skippy
  9033  		}
  9034  	}
  9035  
  9036  	if iNdEx > l {
  9037  		return io.ErrUnexpectedEOF
  9038  	}
  9039  	return nil
  9040  }
  9041  func (m *RunHealthCheckResponse) UnmarshalVT(dAtA []byte) error {
  9042  	l := len(dAtA)
  9043  	iNdEx := 0
  9044  	for iNdEx < l {
  9045  		preIndex := iNdEx
  9046  		var wire uint64
  9047  		for shift := uint(0); ; shift += 7 {
  9048  			if shift >= 64 {
  9049  				return ErrIntOverflow
  9050  			}
  9051  			if iNdEx >= l {
  9052  				return io.ErrUnexpectedEOF
  9053  			}
  9054  			b := dAtA[iNdEx]
  9055  			iNdEx++
  9056  			wire |= uint64(b&0x7F) << shift
  9057  			if b < 0x80 {
  9058  				break
  9059  			}
  9060  		}
  9061  		fieldNum := int32(wire >> 3)
  9062  		wireType := int(wire & 0x7)
  9063  		if wireType == 4 {
  9064  			return fmt.Errorf("proto: RunHealthCheckResponse: wiretype end group for non-group")
  9065  		}
  9066  		if fieldNum <= 0 {
  9067  			return fmt.Errorf("proto: RunHealthCheckResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9068  		}
  9069  		switch fieldNum {
  9070  		default:
  9071  			iNdEx = preIndex
  9072  			skippy, err := skip(dAtA[iNdEx:])
  9073  			if err != nil {
  9074  				return err
  9075  			}
  9076  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9077  				return ErrInvalidLength
  9078  			}
  9079  			if (iNdEx + skippy) > l {
  9080  				return io.ErrUnexpectedEOF
  9081  			}
  9082  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9083  			iNdEx += skippy
  9084  		}
  9085  	}
  9086  
  9087  	if iNdEx > l {
  9088  		return io.ErrUnexpectedEOF
  9089  	}
  9090  	return nil
  9091  }
  9092  func (m *ReloadSchemaRequest) UnmarshalVT(dAtA []byte) error {
  9093  	l := len(dAtA)
  9094  	iNdEx := 0
  9095  	for iNdEx < l {
  9096  		preIndex := iNdEx
  9097  		var wire uint64
  9098  		for shift := uint(0); ; shift += 7 {
  9099  			if shift >= 64 {
  9100  				return ErrIntOverflow
  9101  			}
  9102  			if iNdEx >= l {
  9103  				return io.ErrUnexpectedEOF
  9104  			}
  9105  			b := dAtA[iNdEx]
  9106  			iNdEx++
  9107  			wire |= uint64(b&0x7F) << shift
  9108  			if b < 0x80 {
  9109  				break
  9110  			}
  9111  		}
  9112  		fieldNum := int32(wire >> 3)
  9113  		wireType := int(wire & 0x7)
  9114  		if wireType == 4 {
  9115  			return fmt.Errorf("proto: ReloadSchemaRequest: wiretype end group for non-group")
  9116  		}
  9117  		if fieldNum <= 0 {
  9118  			return fmt.Errorf("proto: ReloadSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9119  		}
  9120  		switch fieldNum {
  9121  		case 1:
  9122  			if wireType != 2 {
  9123  				return fmt.Errorf("proto: wrong wireType = %d for field WaitPosition", wireType)
  9124  			}
  9125  			var stringLen uint64
  9126  			for shift := uint(0); ; shift += 7 {
  9127  				if shift >= 64 {
  9128  					return ErrIntOverflow
  9129  				}
  9130  				if iNdEx >= l {
  9131  					return io.ErrUnexpectedEOF
  9132  				}
  9133  				b := dAtA[iNdEx]
  9134  				iNdEx++
  9135  				stringLen |= uint64(b&0x7F) << shift
  9136  				if b < 0x80 {
  9137  					break
  9138  				}
  9139  			}
  9140  			intStringLen := int(stringLen)
  9141  			if intStringLen < 0 {
  9142  				return ErrInvalidLength
  9143  			}
  9144  			postIndex := iNdEx + intStringLen
  9145  			if postIndex < 0 {
  9146  				return ErrInvalidLength
  9147  			}
  9148  			if postIndex > l {
  9149  				return io.ErrUnexpectedEOF
  9150  			}
  9151  			m.WaitPosition = string(dAtA[iNdEx:postIndex])
  9152  			iNdEx = postIndex
  9153  		default:
  9154  			iNdEx = preIndex
  9155  			skippy, err := skip(dAtA[iNdEx:])
  9156  			if err != nil {
  9157  				return err
  9158  			}
  9159  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9160  				return ErrInvalidLength
  9161  			}
  9162  			if (iNdEx + skippy) > l {
  9163  				return io.ErrUnexpectedEOF
  9164  			}
  9165  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9166  			iNdEx += skippy
  9167  		}
  9168  	}
  9169  
  9170  	if iNdEx > l {
  9171  		return io.ErrUnexpectedEOF
  9172  	}
  9173  	return nil
  9174  }
  9175  func (m *ReloadSchemaResponse) UnmarshalVT(dAtA []byte) error {
  9176  	l := len(dAtA)
  9177  	iNdEx := 0
  9178  	for iNdEx < l {
  9179  		preIndex := iNdEx
  9180  		var wire uint64
  9181  		for shift := uint(0); ; shift += 7 {
  9182  			if shift >= 64 {
  9183  				return ErrIntOverflow
  9184  			}
  9185  			if iNdEx >= l {
  9186  				return io.ErrUnexpectedEOF
  9187  			}
  9188  			b := dAtA[iNdEx]
  9189  			iNdEx++
  9190  			wire |= uint64(b&0x7F) << shift
  9191  			if b < 0x80 {
  9192  				break
  9193  			}
  9194  		}
  9195  		fieldNum := int32(wire >> 3)
  9196  		wireType := int(wire & 0x7)
  9197  		if wireType == 4 {
  9198  			return fmt.Errorf("proto: ReloadSchemaResponse: wiretype end group for non-group")
  9199  		}
  9200  		if fieldNum <= 0 {
  9201  			return fmt.Errorf("proto: ReloadSchemaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9202  		}
  9203  		switch fieldNum {
  9204  		default:
  9205  			iNdEx = preIndex
  9206  			skippy, err := skip(dAtA[iNdEx:])
  9207  			if err != nil {
  9208  				return err
  9209  			}
  9210  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9211  				return ErrInvalidLength
  9212  			}
  9213  			if (iNdEx + skippy) > l {
  9214  				return io.ErrUnexpectedEOF
  9215  			}
  9216  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9217  			iNdEx += skippy
  9218  		}
  9219  	}
  9220  
  9221  	if iNdEx > l {
  9222  		return io.ErrUnexpectedEOF
  9223  	}
  9224  	return nil
  9225  }
  9226  func (m *PreflightSchemaRequest) UnmarshalVT(dAtA []byte) error {
  9227  	l := len(dAtA)
  9228  	iNdEx := 0
  9229  	for iNdEx < l {
  9230  		preIndex := iNdEx
  9231  		var wire uint64
  9232  		for shift := uint(0); ; shift += 7 {
  9233  			if shift >= 64 {
  9234  				return ErrIntOverflow
  9235  			}
  9236  			if iNdEx >= l {
  9237  				return io.ErrUnexpectedEOF
  9238  			}
  9239  			b := dAtA[iNdEx]
  9240  			iNdEx++
  9241  			wire |= uint64(b&0x7F) << shift
  9242  			if b < 0x80 {
  9243  				break
  9244  			}
  9245  		}
  9246  		fieldNum := int32(wire >> 3)
  9247  		wireType := int(wire & 0x7)
  9248  		if wireType == 4 {
  9249  			return fmt.Errorf("proto: PreflightSchemaRequest: wiretype end group for non-group")
  9250  		}
  9251  		if fieldNum <= 0 {
  9252  			return fmt.Errorf("proto: PreflightSchemaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9253  		}
  9254  		switch fieldNum {
  9255  		case 1:
  9256  			if wireType != 2 {
  9257  				return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
  9258  			}
  9259  			var stringLen uint64
  9260  			for shift := uint(0); ; shift += 7 {
  9261  				if shift >= 64 {
  9262  					return ErrIntOverflow
  9263  				}
  9264  				if iNdEx >= l {
  9265  					return io.ErrUnexpectedEOF
  9266  				}
  9267  				b := dAtA[iNdEx]
  9268  				iNdEx++
  9269  				stringLen |= uint64(b&0x7F) << shift
  9270  				if b < 0x80 {
  9271  					break
  9272  				}
  9273  			}
  9274  			intStringLen := int(stringLen)
  9275  			if intStringLen < 0 {
  9276  				return ErrInvalidLength
  9277  			}
  9278  			postIndex := iNdEx + intStringLen
  9279  			if postIndex < 0 {
  9280  				return ErrInvalidLength
  9281  			}
  9282  			if postIndex > l {
  9283  				return io.ErrUnexpectedEOF
  9284  			}
  9285  			m.Changes = append(m.Changes, string(dAtA[iNdEx:postIndex]))
  9286  			iNdEx = postIndex
  9287  		default:
  9288  			iNdEx = preIndex
  9289  			skippy, err := skip(dAtA[iNdEx:])
  9290  			if err != nil {
  9291  				return err
  9292  			}
  9293  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9294  				return ErrInvalidLength
  9295  			}
  9296  			if (iNdEx + skippy) > l {
  9297  				return io.ErrUnexpectedEOF
  9298  			}
  9299  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9300  			iNdEx += skippy
  9301  		}
  9302  	}
  9303  
  9304  	if iNdEx > l {
  9305  		return io.ErrUnexpectedEOF
  9306  	}
  9307  	return nil
  9308  }
  9309  func (m *PreflightSchemaResponse) UnmarshalVT(dAtA []byte) error {
  9310  	l := len(dAtA)
  9311  	iNdEx := 0
  9312  	for iNdEx < l {
  9313  		preIndex := iNdEx
  9314  		var wire uint64
  9315  		for shift := uint(0); ; shift += 7 {
  9316  			if shift >= 64 {
  9317  				return ErrIntOverflow
  9318  			}
  9319  			if iNdEx >= l {
  9320  				return io.ErrUnexpectedEOF
  9321  			}
  9322  			b := dAtA[iNdEx]
  9323  			iNdEx++
  9324  			wire |= uint64(b&0x7F) << shift
  9325  			if b < 0x80 {
  9326  				break
  9327  			}
  9328  		}
  9329  		fieldNum := int32(wire >> 3)
  9330  		wireType := int(wire & 0x7)
  9331  		if wireType == 4 {
  9332  			return fmt.Errorf("proto: PreflightSchemaResponse: wiretype end group for non-group")
  9333  		}
  9334  		if fieldNum <= 0 {
  9335  			return fmt.Errorf("proto: PreflightSchemaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9336  		}
  9337  		switch fieldNum {
  9338  		case 1:
  9339  			if wireType != 2 {
  9340  				return fmt.Errorf("proto: wrong wireType = %d for field ChangeResults", wireType)
  9341  			}
  9342  			var msglen int
  9343  			for shift := uint(0); ; shift += 7 {
  9344  				if shift >= 64 {
  9345  					return ErrIntOverflow
  9346  				}
  9347  				if iNdEx >= l {
  9348  					return io.ErrUnexpectedEOF
  9349  				}
  9350  				b := dAtA[iNdEx]
  9351  				iNdEx++
  9352  				msglen |= int(b&0x7F) << shift
  9353  				if b < 0x80 {
  9354  					break
  9355  				}
  9356  			}
  9357  			if msglen < 0 {
  9358  				return ErrInvalidLength
  9359  			}
  9360  			postIndex := iNdEx + msglen
  9361  			if postIndex < 0 {
  9362  				return ErrInvalidLength
  9363  			}
  9364  			if postIndex > l {
  9365  				return io.ErrUnexpectedEOF
  9366  			}
  9367  			m.ChangeResults = append(m.ChangeResults, &SchemaChangeResult{})
  9368  			if err := m.ChangeResults[len(m.ChangeResults)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9369  				return err
  9370  			}
  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 *ApplySchemaRequest) 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: ApplySchemaRequest: wiretype end group for non-group")
  9418  		}
  9419  		if fieldNum <= 0 {
  9420  			return fmt.Errorf("proto: ApplySchemaRequest: 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 Sql", wireType)
  9426  			}
  9427  			var stringLen uint64
  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  				stringLen |= uint64(b&0x7F) << shift
  9438  				if b < 0x80 {
  9439  					break
  9440  				}
  9441  			}
  9442  			intStringLen := int(stringLen)
  9443  			if intStringLen < 0 {
  9444  				return ErrInvalidLength
  9445  			}
  9446  			postIndex := iNdEx + intStringLen
  9447  			if postIndex < 0 {
  9448  				return ErrInvalidLength
  9449  			}
  9450  			if postIndex > l {
  9451  				return io.ErrUnexpectedEOF
  9452  			}
  9453  			m.Sql = string(dAtA[iNdEx:postIndex])
  9454  			iNdEx = postIndex
  9455  		case 2:
  9456  			if wireType != 0 {
  9457  				return fmt.Errorf("proto: wrong wireType = %d for field Force", wireType)
  9458  			}
  9459  			var v int
  9460  			for shift := uint(0); ; shift += 7 {
  9461  				if shift >= 64 {
  9462  					return ErrIntOverflow
  9463  				}
  9464  				if iNdEx >= l {
  9465  					return io.ErrUnexpectedEOF
  9466  				}
  9467  				b := dAtA[iNdEx]
  9468  				iNdEx++
  9469  				v |= int(b&0x7F) << shift
  9470  				if b < 0x80 {
  9471  					break
  9472  				}
  9473  			}
  9474  			m.Force = bool(v != 0)
  9475  		case 3:
  9476  			if wireType != 0 {
  9477  				return fmt.Errorf("proto: wrong wireType = %d for field AllowReplication", wireType)
  9478  			}
  9479  			var v int
  9480  			for shift := uint(0); ; shift += 7 {
  9481  				if shift >= 64 {
  9482  					return ErrIntOverflow
  9483  				}
  9484  				if iNdEx >= l {
  9485  					return io.ErrUnexpectedEOF
  9486  				}
  9487  				b := dAtA[iNdEx]
  9488  				iNdEx++
  9489  				v |= int(b&0x7F) << shift
  9490  				if b < 0x80 {
  9491  					break
  9492  				}
  9493  			}
  9494  			m.AllowReplication = bool(v != 0)
  9495  		case 4:
  9496  			if wireType != 2 {
  9497  				return fmt.Errorf("proto: wrong wireType = %d for field BeforeSchema", wireType)
  9498  			}
  9499  			var msglen int
  9500  			for shift := uint(0); ; shift += 7 {
  9501  				if shift >= 64 {
  9502  					return ErrIntOverflow
  9503  				}
  9504  				if iNdEx >= l {
  9505  					return io.ErrUnexpectedEOF
  9506  				}
  9507  				b := dAtA[iNdEx]
  9508  				iNdEx++
  9509  				msglen |= int(b&0x7F) << shift
  9510  				if b < 0x80 {
  9511  					break
  9512  				}
  9513  			}
  9514  			if msglen < 0 {
  9515  				return ErrInvalidLength
  9516  			}
  9517  			postIndex := iNdEx + msglen
  9518  			if postIndex < 0 {
  9519  				return ErrInvalidLength
  9520  			}
  9521  			if postIndex > l {
  9522  				return io.ErrUnexpectedEOF
  9523  			}
  9524  			if m.BeforeSchema == nil {
  9525  				m.BeforeSchema = &SchemaDefinition{}
  9526  			}
  9527  			if err := m.BeforeSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9528  				return err
  9529  			}
  9530  			iNdEx = postIndex
  9531  		case 5:
  9532  			if wireType != 2 {
  9533  				return fmt.Errorf("proto: wrong wireType = %d for field AfterSchema", wireType)
  9534  			}
  9535  			var msglen int
  9536  			for shift := uint(0); ; shift += 7 {
  9537  				if shift >= 64 {
  9538  					return ErrIntOverflow
  9539  				}
  9540  				if iNdEx >= l {
  9541  					return io.ErrUnexpectedEOF
  9542  				}
  9543  				b := dAtA[iNdEx]
  9544  				iNdEx++
  9545  				msglen |= int(b&0x7F) << shift
  9546  				if b < 0x80 {
  9547  					break
  9548  				}
  9549  			}
  9550  			if msglen < 0 {
  9551  				return ErrInvalidLength
  9552  			}
  9553  			postIndex := iNdEx + msglen
  9554  			if postIndex < 0 {
  9555  				return ErrInvalidLength
  9556  			}
  9557  			if postIndex > l {
  9558  				return io.ErrUnexpectedEOF
  9559  			}
  9560  			if m.AfterSchema == nil {
  9561  				m.AfterSchema = &SchemaDefinition{}
  9562  			}
  9563  			if err := m.AfterSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9564  				return err
  9565  			}
  9566  			iNdEx = postIndex
  9567  		case 6:
  9568  			if wireType != 2 {
  9569  				return fmt.Errorf("proto: wrong wireType = %d for field SqlMode", wireType)
  9570  			}
  9571  			var stringLen uint64
  9572  			for shift := uint(0); ; shift += 7 {
  9573  				if shift >= 64 {
  9574  					return ErrIntOverflow
  9575  				}
  9576  				if iNdEx >= l {
  9577  					return io.ErrUnexpectedEOF
  9578  				}
  9579  				b := dAtA[iNdEx]
  9580  				iNdEx++
  9581  				stringLen |= uint64(b&0x7F) << shift
  9582  				if b < 0x80 {
  9583  					break
  9584  				}
  9585  			}
  9586  			intStringLen := int(stringLen)
  9587  			if intStringLen < 0 {
  9588  				return ErrInvalidLength
  9589  			}
  9590  			postIndex := iNdEx + intStringLen
  9591  			if postIndex < 0 {
  9592  				return ErrInvalidLength
  9593  			}
  9594  			if postIndex > l {
  9595  				return io.ErrUnexpectedEOF
  9596  			}
  9597  			m.SqlMode = string(dAtA[iNdEx:postIndex])
  9598  			iNdEx = postIndex
  9599  		default:
  9600  			iNdEx = preIndex
  9601  			skippy, err := skip(dAtA[iNdEx:])
  9602  			if err != nil {
  9603  				return err
  9604  			}
  9605  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9606  				return ErrInvalidLength
  9607  			}
  9608  			if (iNdEx + skippy) > l {
  9609  				return io.ErrUnexpectedEOF
  9610  			}
  9611  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9612  			iNdEx += skippy
  9613  		}
  9614  	}
  9615  
  9616  	if iNdEx > l {
  9617  		return io.ErrUnexpectedEOF
  9618  	}
  9619  	return nil
  9620  }
  9621  func (m *ApplySchemaResponse) UnmarshalVT(dAtA []byte) error {
  9622  	l := len(dAtA)
  9623  	iNdEx := 0
  9624  	for iNdEx < l {
  9625  		preIndex := iNdEx
  9626  		var wire uint64
  9627  		for shift := uint(0); ; shift += 7 {
  9628  			if shift >= 64 {
  9629  				return ErrIntOverflow
  9630  			}
  9631  			if iNdEx >= l {
  9632  				return io.ErrUnexpectedEOF
  9633  			}
  9634  			b := dAtA[iNdEx]
  9635  			iNdEx++
  9636  			wire |= uint64(b&0x7F) << shift
  9637  			if b < 0x80 {
  9638  				break
  9639  			}
  9640  		}
  9641  		fieldNum := int32(wire >> 3)
  9642  		wireType := int(wire & 0x7)
  9643  		if wireType == 4 {
  9644  			return fmt.Errorf("proto: ApplySchemaResponse: wiretype end group for non-group")
  9645  		}
  9646  		if fieldNum <= 0 {
  9647  			return fmt.Errorf("proto: ApplySchemaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9648  		}
  9649  		switch fieldNum {
  9650  		case 1:
  9651  			if wireType != 2 {
  9652  				return fmt.Errorf("proto: wrong wireType = %d for field BeforeSchema", wireType)
  9653  			}
  9654  			var msglen int
  9655  			for shift := uint(0); ; shift += 7 {
  9656  				if shift >= 64 {
  9657  					return ErrIntOverflow
  9658  				}
  9659  				if iNdEx >= l {
  9660  					return io.ErrUnexpectedEOF
  9661  				}
  9662  				b := dAtA[iNdEx]
  9663  				iNdEx++
  9664  				msglen |= int(b&0x7F) << shift
  9665  				if b < 0x80 {
  9666  					break
  9667  				}
  9668  			}
  9669  			if msglen < 0 {
  9670  				return ErrInvalidLength
  9671  			}
  9672  			postIndex := iNdEx + msglen
  9673  			if postIndex < 0 {
  9674  				return ErrInvalidLength
  9675  			}
  9676  			if postIndex > l {
  9677  				return io.ErrUnexpectedEOF
  9678  			}
  9679  			if m.BeforeSchema == nil {
  9680  				m.BeforeSchema = &SchemaDefinition{}
  9681  			}
  9682  			if err := m.BeforeSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9683  				return err
  9684  			}
  9685  			iNdEx = postIndex
  9686  		case 2:
  9687  			if wireType != 2 {
  9688  				return fmt.Errorf("proto: wrong wireType = %d for field AfterSchema", wireType)
  9689  			}
  9690  			var msglen int
  9691  			for shift := uint(0); ; shift += 7 {
  9692  				if shift >= 64 {
  9693  					return ErrIntOverflow
  9694  				}
  9695  				if iNdEx >= l {
  9696  					return io.ErrUnexpectedEOF
  9697  				}
  9698  				b := dAtA[iNdEx]
  9699  				iNdEx++
  9700  				msglen |= int(b&0x7F) << shift
  9701  				if b < 0x80 {
  9702  					break
  9703  				}
  9704  			}
  9705  			if msglen < 0 {
  9706  				return ErrInvalidLength
  9707  			}
  9708  			postIndex := iNdEx + msglen
  9709  			if postIndex < 0 {
  9710  				return ErrInvalidLength
  9711  			}
  9712  			if postIndex > l {
  9713  				return io.ErrUnexpectedEOF
  9714  			}
  9715  			if m.AfterSchema == nil {
  9716  				m.AfterSchema = &SchemaDefinition{}
  9717  			}
  9718  			if err := m.AfterSchema.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
  9719  				return err
  9720  			}
  9721  			iNdEx = postIndex
  9722  		default:
  9723  			iNdEx = preIndex
  9724  			skippy, err := skip(dAtA[iNdEx:])
  9725  			if err != nil {
  9726  				return err
  9727  			}
  9728  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9729  				return ErrInvalidLength
  9730  			}
  9731  			if (iNdEx + skippy) > l {
  9732  				return io.ErrUnexpectedEOF
  9733  			}
  9734  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9735  			iNdEx += skippy
  9736  		}
  9737  	}
  9738  
  9739  	if iNdEx > l {
  9740  		return io.ErrUnexpectedEOF
  9741  	}
  9742  	return nil
  9743  }
  9744  func (m *LockTablesRequest) UnmarshalVT(dAtA []byte) error {
  9745  	l := len(dAtA)
  9746  	iNdEx := 0
  9747  	for iNdEx < l {
  9748  		preIndex := iNdEx
  9749  		var wire uint64
  9750  		for shift := uint(0); ; shift += 7 {
  9751  			if shift >= 64 {
  9752  				return ErrIntOverflow
  9753  			}
  9754  			if iNdEx >= l {
  9755  				return io.ErrUnexpectedEOF
  9756  			}
  9757  			b := dAtA[iNdEx]
  9758  			iNdEx++
  9759  			wire |= uint64(b&0x7F) << shift
  9760  			if b < 0x80 {
  9761  				break
  9762  			}
  9763  		}
  9764  		fieldNum := int32(wire >> 3)
  9765  		wireType := int(wire & 0x7)
  9766  		if wireType == 4 {
  9767  			return fmt.Errorf("proto: LockTablesRequest: wiretype end group for non-group")
  9768  		}
  9769  		if fieldNum <= 0 {
  9770  			return fmt.Errorf("proto: LockTablesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9771  		}
  9772  		switch fieldNum {
  9773  		default:
  9774  			iNdEx = preIndex
  9775  			skippy, err := skip(dAtA[iNdEx:])
  9776  			if err != nil {
  9777  				return err
  9778  			}
  9779  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9780  				return ErrInvalidLength
  9781  			}
  9782  			if (iNdEx + skippy) > l {
  9783  				return io.ErrUnexpectedEOF
  9784  			}
  9785  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9786  			iNdEx += skippy
  9787  		}
  9788  	}
  9789  
  9790  	if iNdEx > l {
  9791  		return io.ErrUnexpectedEOF
  9792  	}
  9793  	return nil
  9794  }
  9795  func (m *LockTablesResponse) UnmarshalVT(dAtA []byte) error {
  9796  	l := len(dAtA)
  9797  	iNdEx := 0
  9798  	for iNdEx < l {
  9799  		preIndex := iNdEx
  9800  		var wire uint64
  9801  		for shift := uint(0); ; shift += 7 {
  9802  			if shift >= 64 {
  9803  				return ErrIntOverflow
  9804  			}
  9805  			if iNdEx >= l {
  9806  				return io.ErrUnexpectedEOF
  9807  			}
  9808  			b := dAtA[iNdEx]
  9809  			iNdEx++
  9810  			wire |= uint64(b&0x7F) << shift
  9811  			if b < 0x80 {
  9812  				break
  9813  			}
  9814  		}
  9815  		fieldNum := int32(wire >> 3)
  9816  		wireType := int(wire & 0x7)
  9817  		if wireType == 4 {
  9818  			return fmt.Errorf("proto: LockTablesResponse: wiretype end group for non-group")
  9819  		}
  9820  		if fieldNum <= 0 {
  9821  			return fmt.Errorf("proto: LockTablesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9822  		}
  9823  		switch fieldNum {
  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 *UnlockTablesRequest) 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: UnlockTablesRequest: wiretype end group for non-group")
  9870  		}
  9871  		if fieldNum <= 0 {
  9872  			return fmt.Errorf("proto: UnlockTablesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9873  		}
  9874  		switch fieldNum {
  9875  		default:
  9876  			iNdEx = preIndex
  9877  			skippy, err := skip(dAtA[iNdEx:])
  9878  			if err != nil {
  9879  				return err
  9880  			}
  9881  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9882  				return ErrInvalidLength
  9883  			}
  9884  			if (iNdEx + skippy) > l {
  9885  				return io.ErrUnexpectedEOF
  9886  			}
  9887  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9888  			iNdEx += skippy
  9889  		}
  9890  	}
  9891  
  9892  	if iNdEx > l {
  9893  		return io.ErrUnexpectedEOF
  9894  	}
  9895  	return nil
  9896  }
  9897  func (m *UnlockTablesResponse) UnmarshalVT(dAtA []byte) error {
  9898  	l := len(dAtA)
  9899  	iNdEx := 0
  9900  	for iNdEx < l {
  9901  		preIndex := iNdEx
  9902  		var wire uint64
  9903  		for shift := uint(0); ; shift += 7 {
  9904  			if shift >= 64 {
  9905  				return ErrIntOverflow
  9906  			}
  9907  			if iNdEx >= l {
  9908  				return io.ErrUnexpectedEOF
  9909  			}
  9910  			b := dAtA[iNdEx]
  9911  			iNdEx++
  9912  			wire |= uint64(b&0x7F) << shift
  9913  			if b < 0x80 {
  9914  				break
  9915  			}
  9916  		}
  9917  		fieldNum := int32(wire >> 3)
  9918  		wireType := int(wire & 0x7)
  9919  		if wireType == 4 {
  9920  			return fmt.Errorf("proto: UnlockTablesResponse: wiretype end group for non-group")
  9921  		}
  9922  		if fieldNum <= 0 {
  9923  			return fmt.Errorf("proto: UnlockTablesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  9924  		}
  9925  		switch fieldNum {
  9926  		default:
  9927  			iNdEx = preIndex
  9928  			skippy, err := skip(dAtA[iNdEx:])
  9929  			if err != nil {
  9930  				return err
  9931  			}
  9932  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9933  				return ErrInvalidLength
  9934  			}
  9935  			if (iNdEx + skippy) > l {
  9936  				return io.ErrUnexpectedEOF
  9937  			}
  9938  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
  9939  			iNdEx += skippy
  9940  		}
  9941  	}
  9942  
  9943  	if iNdEx > l {
  9944  		return io.ErrUnexpectedEOF
  9945  	}
  9946  	return nil
  9947  }
  9948  func (m *ExecuteQueryRequest) UnmarshalVT(dAtA []byte) error {
  9949  	l := len(dAtA)
  9950  	iNdEx := 0
  9951  	for iNdEx < l {
  9952  		preIndex := iNdEx
  9953  		var wire uint64
  9954  		for shift := uint(0); ; shift += 7 {
  9955  			if shift >= 64 {
  9956  				return ErrIntOverflow
  9957  			}
  9958  			if iNdEx >= l {
  9959  				return io.ErrUnexpectedEOF
  9960  			}
  9961  			b := dAtA[iNdEx]
  9962  			iNdEx++
  9963  			wire |= uint64(b&0x7F) << shift
  9964  			if b < 0x80 {
  9965  				break
  9966  			}
  9967  		}
  9968  		fieldNum := int32(wire >> 3)
  9969  		wireType := int(wire & 0x7)
  9970  		if wireType == 4 {
  9971  			return fmt.Errorf("proto: ExecuteQueryRequest: wiretype end group for non-group")
  9972  		}
  9973  		if fieldNum <= 0 {
  9974  			return fmt.Errorf("proto: ExecuteQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  9975  		}
  9976  		switch fieldNum {
  9977  		case 1:
  9978  			if wireType != 2 {
  9979  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
  9980  			}
  9981  			var byteLen int
  9982  			for shift := uint(0); ; shift += 7 {
  9983  				if shift >= 64 {
  9984  					return ErrIntOverflow
  9985  				}
  9986  				if iNdEx >= l {
  9987  					return io.ErrUnexpectedEOF
  9988  				}
  9989  				b := dAtA[iNdEx]
  9990  				iNdEx++
  9991  				byteLen |= int(b&0x7F) << shift
  9992  				if b < 0x80 {
  9993  					break
  9994  				}
  9995  			}
  9996  			if byteLen < 0 {
  9997  				return ErrInvalidLength
  9998  			}
  9999  			postIndex := iNdEx + byteLen
 10000  			if postIndex < 0 {
 10001  				return ErrInvalidLength
 10002  			}
 10003  			if postIndex > l {
 10004  				return io.ErrUnexpectedEOF
 10005  			}
 10006  			m.Query = append(m.Query[:0], dAtA[iNdEx:postIndex]...)
 10007  			if m.Query == nil {
 10008  				m.Query = []byte{}
 10009  			}
 10010  			iNdEx = postIndex
 10011  		case 2:
 10012  			if wireType != 2 {
 10013  				return fmt.Errorf("proto: wrong wireType = %d for field DbName", wireType)
 10014  			}
 10015  			var stringLen uint64
 10016  			for shift := uint(0); ; shift += 7 {
 10017  				if shift >= 64 {
 10018  					return ErrIntOverflow
 10019  				}
 10020  				if iNdEx >= l {
 10021  					return io.ErrUnexpectedEOF
 10022  				}
 10023  				b := dAtA[iNdEx]
 10024  				iNdEx++
 10025  				stringLen |= uint64(b&0x7F) << shift
 10026  				if b < 0x80 {
 10027  					break
 10028  				}
 10029  			}
 10030  			intStringLen := int(stringLen)
 10031  			if intStringLen < 0 {
 10032  				return ErrInvalidLength
 10033  			}
 10034  			postIndex := iNdEx + intStringLen
 10035  			if postIndex < 0 {
 10036  				return ErrInvalidLength
 10037  			}
 10038  			if postIndex > l {
 10039  				return io.ErrUnexpectedEOF
 10040  			}
 10041  			m.DbName = string(dAtA[iNdEx:postIndex])
 10042  			iNdEx = postIndex
 10043  		case 3:
 10044  			if wireType != 0 {
 10045  				return fmt.Errorf("proto: wrong wireType = %d for field MaxRows", wireType)
 10046  			}
 10047  			m.MaxRows = 0
 10048  			for shift := uint(0); ; shift += 7 {
 10049  				if shift >= 64 {
 10050  					return ErrIntOverflow
 10051  				}
 10052  				if iNdEx >= l {
 10053  					return io.ErrUnexpectedEOF
 10054  				}
 10055  				b := dAtA[iNdEx]
 10056  				iNdEx++
 10057  				m.MaxRows |= uint64(b&0x7F) << shift
 10058  				if b < 0x80 {
 10059  					break
 10060  				}
 10061  			}
 10062  		case 4:
 10063  			if wireType != 2 {
 10064  				return fmt.Errorf("proto: wrong wireType = %d for field CallerId", 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.CallerId == nil {
 10092  				m.CallerId = &vtrpc.CallerID{}
 10093  			}
 10094  			if err := m.CallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10095  				return err
 10096  			}
 10097  			iNdEx = postIndex
 10098  		default:
 10099  			iNdEx = preIndex
 10100  			skippy, err := skip(dAtA[iNdEx:])
 10101  			if err != nil {
 10102  				return err
 10103  			}
 10104  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10105  				return ErrInvalidLength
 10106  			}
 10107  			if (iNdEx + skippy) > l {
 10108  				return io.ErrUnexpectedEOF
 10109  			}
 10110  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10111  			iNdEx += skippy
 10112  		}
 10113  	}
 10114  
 10115  	if iNdEx > l {
 10116  		return io.ErrUnexpectedEOF
 10117  	}
 10118  	return nil
 10119  }
 10120  func (m *ExecuteQueryResponse) UnmarshalVT(dAtA []byte) error {
 10121  	l := len(dAtA)
 10122  	iNdEx := 0
 10123  	for iNdEx < l {
 10124  		preIndex := iNdEx
 10125  		var wire uint64
 10126  		for shift := uint(0); ; shift += 7 {
 10127  			if shift >= 64 {
 10128  				return ErrIntOverflow
 10129  			}
 10130  			if iNdEx >= l {
 10131  				return io.ErrUnexpectedEOF
 10132  			}
 10133  			b := dAtA[iNdEx]
 10134  			iNdEx++
 10135  			wire |= uint64(b&0x7F) << shift
 10136  			if b < 0x80 {
 10137  				break
 10138  			}
 10139  		}
 10140  		fieldNum := int32(wire >> 3)
 10141  		wireType := int(wire & 0x7)
 10142  		if wireType == 4 {
 10143  			return fmt.Errorf("proto: ExecuteQueryResponse: wiretype end group for non-group")
 10144  		}
 10145  		if fieldNum <= 0 {
 10146  			return fmt.Errorf("proto: ExecuteQueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10147  		}
 10148  		switch fieldNum {
 10149  		case 1:
 10150  			if wireType != 2 {
 10151  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 10152  			}
 10153  			var msglen int
 10154  			for shift := uint(0); ; shift += 7 {
 10155  				if shift >= 64 {
 10156  					return ErrIntOverflow
 10157  				}
 10158  				if iNdEx >= l {
 10159  					return io.ErrUnexpectedEOF
 10160  				}
 10161  				b := dAtA[iNdEx]
 10162  				iNdEx++
 10163  				msglen |= int(b&0x7F) << shift
 10164  				if b < 0x80 {
 10165  					break
 10166  				}
 10167  			}
 10168  			if msglen < 0 {
 10169  				return ErrInvalidLength
 10170  			}
 10171  			postIndex := iNdEx + msglen
 10172  			if postIndex < 0 {
 10173  				return ErrInvalidLength
 10174  			}
 10175  			if postIndex > l {
 10176  				return io.ErrUnexpectedEOF
 10177  			}
 10178  			if m.Result == nil {
 10179  				m.Result = &query.QueryResult{}
 10180  			}
 10181  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10182  				return err
 10183  			}
 10184  			iNdEx = postIndex
 10185  		default:
 10186  			iNdEx = preIndex
 10187  			skippy, err := skip(dAtA[iNdEx:])
 10188  			if err != nil {
 10189  				return err
 10190  			}
 10191  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10192  				return ErrInvalidLength
 10193  			}
 10194  			if (iNdEx + skippy) > l {
 10195  				return io.ErrUnexpectedEOF
 10196  			}
 10197  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10198  			iNdEx += skippy
 10199  		}
 10200  	}
 10201  
 10202  	if iNdEx > l {
 10203  		return io.ErrUnexpectedEOF
 10204  	}
 10205  	return nil
 10206  }
 10207  func (m *ExecuteFetchAsDbaRequest) UnmarshalVT(dAtA []byte) error {
 10208  	l := len(dAtA)
 10209  	iNdEx := 0
 10210  	for iNdEx < l {
 10211  		preIndex := iNdEx
 10212  		var wire uint64
 10213  		for shift := uint(0); ; shift += 7 {
 10214  			if shift >= 64 {
 10215  				return ErrIntOverflow
 10216  			}
 10217  			if iNdEx >= l {
 10218  				return io.ErrUnexpectedEOF
 10219  			}
 10220  			b := dAtA[iNdEx]
 10221  			iNdEx++
 10222  			wire |= uint64(b&0x7F) << shift
 10223  			if b < 0x80 {
 10224  				break
 10225  			}
 10226  		}
 10227  		fieldNum := int32(wire >> 3)
 10228  		wireType := int(wire & 0x7)
 10229  		if wireType == 4 {
 10230  			return fmt.Errorf("proto: ExecuteFetchAsDbaRequest: wiretype end group for non-group")
 10231  		}
 10232  		if fieldNum <= 0 {
 10233  			return fmt.Errorf("proto: ExecuteFetchAsDbaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10234  		}
 10235  		switch fieldNum {
 10236  		case 1:
 10237  			if wireType != 2 {
 10238  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 10239  			}
 10240  			var byteLen int
 10241  			for shift := uint(0); ; shift += 7 {
 10242  				if shift >= 64 {
 10243  					return ErrIntOverflow
 10244  				}
 10245  				if iNdEx >= l {
 10246  					return io.ErrUnexpectedEOF
 10247  				}
 10248  				b := dAtA[iNdEx]
 10249  				iNdEx++
 10250  				byteLen |= int(b&0x7F) << shift
 10251  				if b < 0x80 {
 10252  					break
 10253  				}
 10254  			}
 10255  			if byteLen < 0 {
 10256  				return ErrInvalidLength
 10257  			}
 10258  			postIndex := iNdEx + byteLen
 10259  			if postIndex < 0 {
 10260  				return ErrInvalidLength
 10261  			}
 10262  			if postIndex > l {
 10263  				return io.ErrUnexpectedEOF
 10264  			}
 10265  			m.Query = append(m.Query[:0], dAtA[iNdEx:postIndex]...)
 10266  			if m.Query == nil {
 10267  				m.Query = []byte{}
 10268  			}
 10269  			iNdEx = postIndex
 10270  		case 2:
 10271  			if wireType != 2 {
 10272  				return fmt.Errorf("proto: wrong wireType = %d for field DbName", wireType)
 10273  			}
 10274  			var stringLen uint64
 10275  			for shift := uint(0); ; shift += 7 {
 10276  				if shift >= 64 {
 10277  					return ErrIntOverflow
 10278  				}
 10279  				if iNdEx >= l {
 10280  					return io.ErrUnexpectedEOF
 10281  				}
 10282  				b := dAtA[iNdEx]
 10283  				iNdEx++
 10284  				stringLen |= uint64(b&0x7F) << shift
 10285  				if b < 0x80 {
 10286  					break
 10287  				}
 10288  			}
 10289  			intStringLen := int(stringLen)
 10290  			if intStringLen < 0 {
 10291  				return ErrInvalidLength
 10292  			}
 10293  			postIndex := iNdEx + intStringLen
 10294  			if postIndex < 0 {
 10295  				return ErrInvalidLength
 10296  			}
 10297  			if postIndex > l {
 10298  				return io.ErrUnexpectedEOF
 10299  			}
 10300  			m.DbName = string(dAtA[iNdEx:postIndex])
 10301  			iNdEx = postIndex
 10302  		case 3:
 10303  			if wireType != 0 {
 10304  				return fmt.Errorf("proto: wrong wireType = %d for field MaxRows", wireType)
 10305  			}
 10306  			m.MaxRows = 0
 10307  			for shift := uint(0); ; shift += 7 {
 10308  				if shift >= 64 {
 10309  					return ErrIntOverflow
 10310  				}
 10311  				if iNdEx >= l {
 10312  					return io.ErrUnexpectedEOF
 10313  				}
 10314  				b := dAtA[iNdEx]
 10315  				iNdEx++
 10316  				m.MaxRows |= uint64(b&0x7F) << shift
 10317  				if b < 0x80 {
 10318  					break
 10319  				}
 10320  			}
 10321  		case 4:
 10322  			if wireType != 0 {
 10323  				return fmt.Errorf("proto: wrong wireType = %d for field DisableBinlogs", wireType)
 10324  			}
 10325  			var v int
 10326  			for shift := uint(0); ; shift += 7 {
 10327  				if shift >= 64 {
 10328  					return ErrIntOverflow
 10329  				}
 10330  				if iNdEx >= l {
 10331  					return io.ErrUnexpectedEOF
 10332  				}
 10333  				b := dAtA[iNdEx]
 10334  				iNdEx++
 10335  				v |= int(b&0x7F) << shift
 10336  				if b < 0x80 {
 10337  					break
 10338  				}
 10339  			}
 10340  			m.DisableBinlogs = bool(v != 0)
 10341  		case 5:
 10342  			if wireType != 0 {
 10343  				return fmt.Errorf("proto: wrong wireType = %d for field ReloadSchema", wireType)
 10344  			}
 10345  			var v int
 10346  			for shift := uint(0); ; shift += 7 {
 10347  				if shift >= 64 {
 10348  					return ErrIntOverflow
 10349  				}
 10350  				if iNdEx >= l {
 10351  					return io.ErrUnexpectedEOF
 10352  				}
 10353  				b := dAtA[iNdEx]
 10354  				iNdEx++
 10355  				v |= int(b&0x7F) << shift
 10356  				if b < 0x80 {
 10357  					break
 10358  				}
 10359  			}
 10360  			m.ReloadSchema = bool(v != 0)
 10361  		default:
 10362  			iNdEx = preIndex
 10363  			skippy, err := skip(dAtA[iNdEx:])
 10364  			if err != nil {
 10365  				return err
 10366  			}
 10367  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10368  				return ErrInvalidLength
 10369  			}
 10370  			if (iNdEx + skippy) > l {
 10371  				return io.ErrUnexpectedEOF
 10372  			}
 10373  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10374  			iNdEx += skippy
 10375  		}
 10376  	}
 10377  
 10378  	if iNdEx > l {
 10379  		return io.ErrUnexpectedEOF
 10380  	}
 10381  	return nil
 10382  }
 10383  func (m *ExecuteFetchAsDbaResponse) UnmarshalVT(dAtA []byte) error {
 10384  	l := len(dAtA)
 10385  	iNdEx := 0
 10386  	for iNdEx < l {
 10387  		preIndex := iNdEx
 10388  		var wire uint64
 10389  		for shift := uint(0); ; shift += 7 {
 10390  			if shift >= 64 {
 10391  				return ErrIntOverflow
 10392  			}
 10393  			if iNdEx >= l {
 10394  				return io.ErrUnexpectedEOF
 10395  			}
 10396  			b := dAtA[iNdEx]
 10397  			iNdEx++
 10398  			wire |= uint64(b&0x7F) << shift
 10399  			if b < 0x80 {
 10400  				break
 10401  			}
 10402  		}
 10403  		fieldNum := int32(wire >> 3)
 10404  		wireType := int(wire & 0x7)
 10405  		if wireType == 4 {
 10406  			return fmt.Errorf("proto: ExecuteFetchAsDbaResponse: wiretype end group for non-group")
 10407  		}
 10408  		if fieldNum <= 0 {
 10409  			return fmt.Errorf("proto: ExecuteFetchAsDbaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10410  		}
 10411  		switch fieldNum {
 10412  		case 1:
 10413  			if wireType != 2 {
 10414  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 10415  			}
 10416  			var msglen int
 10417  			for shift := uint(0); ; shift += 7 {
 10418  				if shift >= 64 {
 10419  					return ErrIntOverflow
 10420  				}
 10421  				if iNdEx >= l {
 10422  					return io.ErrUnexpectedEOF
 10423  				}
 10424  				b := dAtA[iNdEx]
 10425  				iNdEx++
 10426  				msglen |= int(b&0x7F) << shift
 10427  				if b < 0x80 {
 10428  					break
 10429  				}
 10430  			}
 10431  			if msglen < 0 {
 10432  				return ErrInvalidLength
 10433  			}
 10434  			postIndex := iNdEx + msglen
 10435  			if postIndex < 0 {
 10436  				return ErrInvalidLength
 10437  			}
 10438  			if postIndex > l {
 10439  				return io.ErrUnexpectedEOF
 10440  			}
 10441  			if m.Result == nil {
 10442  				m.Result = &query.QueryResult{}
 10443  			}
 10444  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10445  				return err
 10446  			}
 10447  			iNdEx = postIndex
 10448  		default:
 10449  			iNdEx = preIndex
 10450  			skippy, err := skip(dAtA[iNdEx:])
 10451  			if err != nil {
 10452  				return err
 10453  			}
 10454  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10455  				return ErrInvalidLength
 10456  			}
 10457  			if (iNdEx + skippy) > l {
 10458  				return io.ErrUnexpectedEOF
 10459  			}
 10460  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10461  			iNdEx += skippy
 10462  		}
 10463  	}
 10464  
 10465  	if iNdEx > l {
 10466  		return io.ErrUnexpectedEOF
 10467  	}
 10468  	return nil
 10469  }
 10470  func (m *ExecuteFetchAsAllPrivsRequest) UnmarshalVT(dAtA []byte) error {
 10471  	l := len(dAtA)
 10472  	iNdEx := 0
 10473  	for iNdEx < l {
 10474  		preIndex := iNdEx
 10475  		var wire uint64
 10476  		for shift := uint(0); ; shift += 7 {
 10477  			if shift >= 64 {
 10478  				return ErrIntOverflow
 10479  			}
 10480  			if iNdEx >= l {
 10481  				return io.ErrUnexpectedEOF
 10482  			}
 10483  			b := dAtA[iNdEx]
 10484  			iNdEx++
 10485  			wire |= uint64(b&0x7F) << shift
 10486  			if b < 0x80 {
 10487  				break
 10488  			}
 10489  		}
 10490  		fieldNum := int32(wire >> 3)
 10491  		wireType := int(wire & 0x7)
 10492  		if wireType == 4 {
 10493  			return fmt.Errorf("proto: ExecuteFetchAsAllPrivsRequest: wiretype end group for non-group")
 10494  		}
 10495  		if fieldNum <= 0 {
 10496  			return fmt.Errorf("proto: ExecuteFetchAsAllPrivsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10497  		}
 10498  		switch fieldNum {
 10499  		case 1:
 10500  			if wireType != 2 {
 10501  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 10502  			}
 10503  			var byteLen int
 10504  			for shift := uint(0); ; shift += 7 {
 10505  				if shift >= 64 {
 10506  					return ErrIntOverflow
 10507  				}
 10508  				if iNdEx >= l {
 10509  					return io.ErrUnexpectedEOF
 10510  				}
 10511  				b := dAtA[iNdEx]
 10512  				iNdEx++
 10513  				byteLen |= int(b&0x7F) << shift
 10514  				if b < 0x80 {
 10515  					break
 10516  				}
 10517  			}
 10518  			if byteLen < 0 {
 10519  				return ErrInvalidLength
 10520  			}
 10521  			postIndex := iNdEx + byteLen
 10522  			if postIndex < 0 {
 10523  				return ErrInvalidLength
 10524  			}
 10525  			if postIndex > l {
 10526  				return io.ErrUnexpectedEOF
 10527  			}
 10528  			m.Query = append(m.Query[:0], dAtA[iNdEx:postIndex]...)
 10529  			if m.Query == nil {
 10530  				m.Query = []byte{}
 10531  			}
 10532  			iNdEx = postIndex
 10533  		case 2:
 10534  			if wireType != 2 {
 10535  				return fmt.Errorf("proto: wrong wireType = %d for field DbName", wireType)
 10536  			}
 10537  			var stringLen uint64
 10538  			for shift := uint(0); ; shift += 7 {
 10539  				if shift >= 64 {
 10540  					return ErrIntOverflow
 10541  				}
 10542  				if iNdEx >= l {
 10543  					return io.ErrUnexpectedEOF
 10544  				}
 10545  				b := dAtA[iNdEx]
 10546  				iNdEx++
 10547  				stringLen |= uint64(b&0x7F) << shift
 10548  				if b < 0x80 {
 10549  					break
 10550  				}
 10551  			}
 10552  			intStringLen := int(stringLen)
 10553  			if intStringLen < 0 {
 10554  				return ErrInvalidLength
 10555  			}
 10556  			postIndex := iNdEx + intStringLen
 10557  			if postIndex < 0 {
 10558  				return ErrInvalidLength
 10559  			}
 10560  			if postIndex > l {
 10561  				return io.ErrUnexpectedEOF
 10562  			}
 10563  			m.DbName = string(dAtA[iNdEx:postIndex])
 10564  			iNdEx = postIndex
 10565  		case 3:
 10566  			if wireType != 0 {
 10567  				return fmt.Errorf("proto: wrong wireType = %d for field MaxRows", wireType)
 10568  			}
 10569  			m.MaxRows = 0
 10570  			for shift := uint(0); ; shift += 7 {
 10571  				if shift >= 64 {
 10572  					return ErrIntOverflow
 10573  				}
 10574  				if iNdEx >= l {
 10575  					return io.ErrUnexpectedEOF
 10576  				}
 10577  				b := dAtA[iNdEx]
 10578  				iNdEx++
 10579  				m.MaxRows |= uint64(b&0x7F) << shift
 10580  				if b < 0x80 {
 10581  					break
 10582  				}
 10583  			}
 10584  		case 4:
 10585  			if wireType != 0 {
 10586  				return fmt.Errorf("proto: wrong wireType = %d for field ReloadSchema", wireType)
 10587  			}
 10588  			var v int
 10589  			for shift := uint(0); ; shift += 7 {
 10590  				if shift >= 64 {
 10591  					return ErrIntOverflow
 10592  				}
 10593  				if iNdEx >= l {
 10594  					return io.ErrUnexpectedEOF
 10595  				}
 10596  				b := dAtA[iNdEx]
 10597  				iNdEx++
 10598  				v |= int(b&0x7F) << shift
 10599  				if b < 0x80 {
 10600  					break
 10601  				}
 10602  			}
 10603  			m.ReloadSchema = bool(v != 0)
 10604  		default:
 10605  			iNdEx = preIndex
 10606  			skippy, err := skip(dAtA[iNdEx:])
 10607  			if err != nil {
 10608  				return err
 10609  			}
 10610  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10611  				return ErrInvalidLength
 10612  			}
 10613  			if (iNdEx + skippy) > l {
 10614  				return io.ErrUnexpectedEOF
 10615  			}
 10616  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10617  			iNdEx += skippy
 10618  		}
 10619  	}
 10620  
 10621  	if iNdEx > l {
 10622  		return io.ErrUnexpectedEOF
 10623  	}
 10624  	return nil
 10625  }
 10626  func (m *ExecuteFetchAsAllPrivsResponse) UnmarshalVT(dAtA []byte) error {
 10627  	l := len(dAtA)
 10628  	iNdEx := 0
 10629  	for iNdEx < l {
 10630  		preIndex := iNdEx
 10631  		var wire uint64
 10632  		for shift := uint(0); ; shift += 7 {
 10633  			if shift >= 64 {
 10634  				return ErrIntOverflow
 10635  			}
 10636  			if iNdEx >= l {
 10637  				return io.ErrUnexpectedEOF
 10638  			}
 10639  			b := dAtA[iNdEx]
 10640  			iNdEx++
 10641  			wire |= uint64(b&0x7F) << shift
 10642  			if b < 0x80 {
 10643  				break
 10644  			}
 10645  		}
 10646  		fieldNum := int32(wire >> 3)
 10647  		wireType := int(wire & 0x7)
 10648  		if wireType == 4 {
 10649  			return fmt.Errorf("proto: ExecuteFetchAsAllPrivsResponse: wiretype end group for non-group")
 10650  		}
 10651  		if fieldNum <= 0 {
 10652  			return fmt.Errorf("proto: ExecuteFetchAsAllPrivsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10653  		}
 10654  		switch fieldNum {
 10655  		case 1:
 10656  			if wireType != 2 {
 10657  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 10658  			}
 10659  			var msglen int
 10660  			for shift := uint(0); ; shift += 7 {
 10661  				if shift >= 64 {
 10662  					return ErrIntOverflow
 10663  				}
 10664  				if iNdEx >= l {
 10665  					return io.ErrUnexpectedEOF
 10666  				}
 10667  				b := dAtA[iNdEx]
 10668  				iNdEx++
 10669  				msglen |= int(b&0x7F) << shift
 10670  				if b < 0x80 {
 10671  					break
 10672  				}
 10673  			}
 10674  			if msglen < 0 {
 10675  				return ErrInvalidLength
 10676  			}
 10677  			postIndex := iNdEx + msglen
 10678  			if postIndex < 0 {
 10679  				return ErrInvalidLength
 10680  			}
 10681  			if postIndex > l {
 10682  				return io.ErrUnexpectedEOF
 10683  			}
 10684  			if m.Result == nil {
 10685  				m.Result = &query.QueryResult{}
 10686  			}
 10687  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10688  				return err
 10689  			}
 10690  			iNdEx = postIndex
 10691  		default:
 10692  			iNdEx = preIndex
 10693  			skippy, err := skip(dAtA[iNdEx:])
 10694  			if err != nil {
 10695  				return err
 10696  			}
 10697  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10698  				return ErrInvalidLength
 10699  			}
 10700  			if (iNdEx + skippy) > l {
 10701  				return io.ErrUnexpectedEOF
 10702  			}
 10703  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10704  			iNdEx += skippy
 10705  		}
 10706  	}
 10707  
 10708  	if iNdEx > l {
 10709  		return io.ErrUnexpectedEOF
 10710  	}
 10711  	return nil
 10712  }
 10713  func (m *ExecuteFetchAsAppRequest) UnmarshalVT(dAtA []byte) error {
 10714  	l := len(dAtA)
 10715  	iNdEx := 0
 10716  	for iNdEx < l {
 10717  		preIndex := iNdEx
 10718  		var wire uint64
 10719  		for shift := uint(0); ; shift += 7 {
 10720  			if shift >= 64 {
 10721  				return ErrIntOverflow
 10722  			}
 10723  			if iNdEx >= l {
 10724  				return io.ErrUnexpectedEOF
 10725  			}
 10726  			b := dAtA[iNdEx]
 10727  			iNdEx++
 10728  			wire |= uint64(b&0x7F) << shift
 10729  			if b < 0x80 {
 10730  				break
 10731  			}
 10732  		}
 10733  		fieldNum := int32(wire >> 3)
 10734  		wireType := int(wire & 0x7)
 10735  		if wireType == 4 {
 10736  			return fmt.Errorf("proto: ExecuteFetchAsAppRequest: wiretype end group for non-group")
 10737  		}
 10738  		if fieldNum <= 0 {
 10739  			return fmt.Errorf("proto: ExecuteFetchAsAppRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10740  		}
 10741  		switch fieldNum {
 10742  		case 1:
 10743  			if wireType != 2 {
 10744  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 10745  			}
 10746  			var byteLen int
 10747  			for shift := uint(0); ; shift += 7 {
 10748  				if shift >= 64 {
 10749  					return ErrIntOverflow
 10750  				}
 10751  				if iNdEx >= l {
 10752  					return io.ErrUnexpectedEOF
 10753  				}
 10754  				b := dAtA[iNdEx]
 10755  				iNdEx++
 10756  				byteLen |= int(b&0x7F) << shift
 10757  				if b < 0x80 {
 10758  					break
 10759  				}
 10760  			}
 10761  			if byteLen < 0 {
 10762  				return ErrInvalidLength
 10763  			}
 10764  			postIndex := iNdEx + byteLen
 10765  			if postIndex < 0 {
 10766  				return ErrInvalidLength
 10767  			}
 10768  			if postIndex > l {
 10769  				return io.ErrUnexpectedEOF
 10770  			}
 10771  			m.Query = append(m.Query[:0], dAtA[iNdEx:postIndex]...)
 10772  			if m.Query == nil {
 10773  				m.Query = []byte{}
 10774  			}
 10775  			iNdEx = postIndex
 10776  		case 2:
 10777  			if wireType != 0 {
 10778  				return fmt.Errorf("proto: wrong wireType = %d for field MaxRows", wireType)
 10779  			}
 10780  			m.MaxRows = 0
 10781  			for shift := uint(0); ; shift += 7 {
 10782  				if shift >= 64 {
 10783  					return ErrIntOverflow
 10784  				}
 10785  				if iNdEx >= l {
 10786  					return io.ErrUnexpectedEOF
 10787  				}
 10788  				b := dAtA[iNdEx]
 10789  				iNdEx++
 10790  				m.MaxRows |= uint64(b&0x7F) << shift
 10791  				if b < 0x80 {
 10792  					break
 10793  				}
 10794  			}
 10795  		default:
 10796  			iNdEx = preIndex
 10797  			skippy, err := skip(dAtA[iNdEx:])
 10798  			if err != nil {
 10799  				return err
 10800  			}
 10801  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10802  				return ErrInvalidLength
 10803  			}
 10804  			if (iNdEx + skippy) > l {
 10805  				return io.ErrUnexpectedEOF
 10806  			}
 10807  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10808  			iNdEx += skippy
 10809  		}
 10810  	}
 10811  
 10812  	if iNdEx > l {
 10813  		return io.ErrUnexpectedEOF
 10814  	}
 10815  	return nil
 10816  }
 10817  func (m *ExecuteFetchAsAppResponse) UnmarshalVT(dAtA []byte) error {
 10818  	l := len(dAtA)
 10819  	iNdEx := 0
 10820  	for iNdEx < l {
 10821  		preIndex := iNdEx
 10822  		var wire uint64
 10823  		for shift := uint(0); ; shift += 7 {
 10824  			if shift >= 64 {
 10825  				return ErrIntOverflow
 10826  			}
 10827  			if iNdEx >= l {
 10828  				return io.ErrUnexpectedEOF
 10829  			}
 10830  			b := dAtA[iNdEx]
 10831  			iNdEx++
 10832  			wire |= uint64(b&0x7F) << shift
 10833  			if b < 0x80 {
 10834  				break
 10835  			}
 10836  		}
 10837  		fieldNum := int32(wire >> 3)
 10838  		wireType := int(wire & 0x7)
 10839  		if wireType == 4 {
 10840  			return fmt.Errorf("proto: ExecuteFetchAsAppResponse: wiretype end group for non-group")
 10841  		}
 10842  		if fieldNum <= 0 {
 10843  			return fmt.Errorf("proto: ExecuteFetchAsAppResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10844  		}
 10845  		switch fieldNum {
 10846  		case 1:
 10847  			if wireType != 2 {
 10848  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 10849  			}
 10850  			var msglen int
 10851  			for shift := uint(0); ; shift += 7 {
 10852  				if shift >= 64 {
 10853  					return ErrIntOverflow
 10854  				}
 10855  				if iNdEx >= l {
 10856  					return io.ErrUnexpectedEOF
 10857  				}
 10858  				b := dAtA[iNdEx]
 10859  				iNdEx++
 10860  				msglen |= int(b&0x7F) << shift
 10861  				if b < 0x80 {
 10862  					break
 10863  				}
 10864  			}
 10865  			if msglen < 0 {
 10866  				return ErrInvalidLength
 10867  			}
 10868  			postIndex := iNdEx + msglen
 10869  			if postIndex < 0 {
 10870  				return ErrInvalidLength
 10871  			}
 10872  			if postIndex > l {
 10873  				return io.ErrUnexpectedEOF
 10874  			}
 10875  			if m.Result == nil {
 10876  				m.Result = &query.QueryResult{}
 10877  			}
 10878  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 10879  				return err
 10880  			}
 10881  			iNdEx = postIndex
 10882  		default:
 10883  			iNdEx = preIndex
 10884  			skippy, err := skip(dAtA[iNdEx:])
 10885  			if err != nil {
 10886  				return err
 10887  			}
 10888  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10889  				return ErrInvalidLength
 10890  			}
 10891  			if (iNdEx + skippy) > l {
 10892  				return io.ErrUnexpectedEOF
 10893  			}
 10894  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10895  			iNdEx += skippy
 10896  		}
 10897  	}
 10898  
 10899  	if iNdEx > l {
 10900  		return io.ErrUnexpectedEOF
 10901  	}
 10902  	return nil
 10903  }
 10904  func (m *ReplicationStatusRequest) UnmarshalVT(dAtA []byte) error {
 10905  	l := len(dAtA)
 10906  	iNdEx := 0
 10907  	for iNdEx < l {
 10908  		preIndex := iNdEx
 10909  		var wire uint64
 10910  		for shift := uint(0); ; shift += 7 {
 10911  			if shift >= 64 {
 10912  				return ErrIntOverflow
 10913  			}
 10914  			if iNdEx >= l {
 10915  				return io.ErrUnexpectedEOF
 10916  			}
 10917  			b := dAtA[iNdEx]
 10918  			iNdEx++
 10919  			wire |= uint64(b&0x7F) << shift
 10920  			if b < 0x80 {
 10921  				break
 10922  			}
 10923  		}
 10924  		fieldNum := int32(wire >> 3)
 10925  		wireType := int(wire & 0x7)
 10926  		if wireType == 4 {
 10927  			return fmt.Errorf("proto: ReplicationStatusRequest: wiretype end group for non-group")
 10928  		}
 10929  		if fieldNum <= 0 {
 10930  			return fmt.Errorf("proto: ReplicationStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 10931  		}
 10932  		switch fieldNum {
 10933  		default:
 10934  			iNdEx = preIndex
 10935  			skippy, err := skip(dAtA[iNdEx:])
 10936  			if err != nil {
 10937  				return err
 10938  			}
 10939  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10940  				return ErrInvalidLength
 10941  			}
 10942  			if (iNdEx + skippy) > l {
 10943  				return io.ErrUnexpectedEOF
 10944  			}
 10945  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 10946  			iNdEx += skippy
 10947  		}
 10948  	}
 10949  
 10950  	if iNdEx > l {
 10951  		return io.ErrUnexpectedEOF
 10952  	}
 10953  	return nil
 10954  }
 10955  func (m *ReplicationStatusResponse) UnmarshalVT(dAtA []byte) error {
 10956  	l := len(dAtA)
 10957  	iNdEx := 0
 10958  	for iNdEx < l {
 10959  		preIndex := iNdEx
 10960  		var wire uint64
 10961  		for shift := uint(0); ; shift += 7 {
 10962  			if shift >= 64 {
 10963  				return ErrIntOverflow
 10964  			}
 10965  			if iNdEx >= l {
 10966  				return io.ErrUnexpectedEOF
 10967  			}
 10968  			b := dAtA[iNdEx]
 10969  			iNdEx++
 10970  			wire |= uint64(b&0x7F) << shift
 10971  			if b < 0x80 {
 10972  				break
 10973  			}
 10974  		}
 10975  		fieldNum := int32(wire >> 3)
 10976  		wireType := int(wire & 0x7)
 10977  		if wireType == 4 {
 10978  			return fmt.Errorf("proto: ReplicationStatusResponse: wiretype end group for non-group")
 10979  		}
 10980  		if fieldNum <= 0 {
 10981  			return fmt.Errorf("proto: ReplicationStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 10982  		}
 10983  		switch fieldNum {
 10984  		case 1:
 10985  			if wireType != 2 {
 10986  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 10987  			}
 10988  			var msglen int
 10989  			for shift := uint(0); ; shift += 7 {
 10990  				if shift >= 64 {
 10991  					return ErrIntOverflow
 10992  				}
 10993  				if iNdEx >= l {
 10994  					return io.ErrUnexpectedEOF
 10995  				}
 10996  				b := dAtA[iNdEx]
 10997  				iNdEx++
 10998  				msglen |= int(b&0x7F) << shift
 10999  				if b < 0x80 {
 11000  					break
 11001  				}
 11002  			}
 11003  			if msglen < 0 {
 11004  				return ErrInvalidLength
 11005  			}
 11006  			postIndex := iNdEx + msglen
 11007  			if postIndex < 0 {
 11008  				return ErrInvalidLength
 11009  			}
 11010  			if postIndex > l {
 11011  				return io.ErrUnexpectedEOF
 11012  			}
 11013  			if m.Status == nil {
 11014  				m.Status = &replicationdata.Status{}
 11015  			}
 11016  			if err := m.Status.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11017  				return err
 11018  			}
 11019  			iNdEx = postIndex
 11020  		default:
 11021  			iNdEx = preIndex
 11022  			skippy, err := skip(dAtA[iNdEx:])
 11023  			if err != nil {
 11024  				return err
 11025  			}
 11026  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11027  				return ErrInvalidLength
 11028  			}
 11029  			if (iNdEx + skippy) > l {
 11030  				return io.ErrUnexpectedEOF
 11031  			}
 11032  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11033  			iNdEx += skippy
 11034  		}
 11035  	}
 11036  
 11037  	if iNdEx > l {
 11038  		return io.ErrUnexpectedEOF
 11039  	}
 11040  	return nil
 11041  }
 11042  func (m *PrimaryStatusRequest) UnmarshalVT(dAtA []byte) error {
 11043  	l := len(dAtA)
 11044  	iNdEx := 0
 11045  	for iNdEx < l {
 11046  		preIndex := iNdEx
 11047  		var wire uint64
 11048  		for shift := uint(0); ; shift += 7 {
 11049  			if shift >= 64 {
 11050  				return ErrIntOverflow
 11051  			}
 11052  			if iNdEx >= l {
 11053  				return io.ErrUnexpectedEOF
 11054  			}
 11055  			b := dAtA[iNdEx]
 11056  			iNdEx++
 11057  			wire |= uint64(b&0x7F) << shift
 11058  			if b < 0x80 {
 11059  				break
 11060  			}
 11061  		}
 11062  		fieldNum := int32(wire >> 3)
 11063  		wireType := int(wire & 0x7)
 11064  		if wireType == 4 {
 11065  			return fmt.Errorf("proto: PrimaryStatusRequest: wiretype end group for non-group")
 11066  		}
 11067  		if fieldNum <= 0 {
 11068  			return fmt.Errorf("proto: PrimaryStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11069  		}
 11070  		switch fieldNum {
 11071  		default:
 11072  			iNdEx = preIndex
 11073  			skippy, err := skip(dAtA[iNdEx:])
 11074  			if err != nil {
 11075  				return err
 11076  			}
 11077  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11078  				return ErrInvalidLength
 11079  			}
 11080  			if (iNdEx + skippy) > l {
 11081  				return io.ErrUnexpectedEOF
 11082  			}
 11083  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11084  			iNdEx += skippy
 11085  		}
 11086  	}
 11087  
 11088  	if iNdEx > l {
 11089  		return io.ErrUnexpectedEOF
 11090  	}
 11091  	return nil
 11092  }
 11093  func (m *PrimaryStatusResponse) UnmarshalVT(dAtA []byte) error {
 11094  	l := len(dAtA)
 11095  	iNdEx := 0
 11096  	for iNdEx < l {
 11097  		preIndex := iNdEx
 11098  		var wire uint64
 11099  		for shift := uint(0); ; shift += 7 {
 11100  			if shift >= 64 {
 11101  				return ErrIntOverflow
 11102  			}
 11103  			if iNdEx >= l {
 11104  				return io.ErrUnexpectedEOF
 11105  			}
 11106  			b := dAtA[iNdEx]
 11107  			iNdEx++
 11108  			wire |= uint64(b&0x7F) << shift
 11109  			if b < 0x80 {
 11110  				break
 11111  			}
 11112  		}
 11113  		fieldNum := int32(wire >> 3)
 11114  		wireType := int(wire & 0x7)
 11115  		if wireType == 4 {
 11116  			return fmt.Errorf("proto: PrimaryStatusResponse: wiretype end group for non-group")
 11117  		}
 11118  		if fieldNum <= 0 {
 11119  			return fmt.Errorf("proto: PrimaryStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11120  		}
 11121  		switch fieldNum {
 11122  		case 1:
 11123  			if wireType != 2 {
 11124  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 11125  			}
 11126  			var msglen int
 11127  			for shift := uint(0); ; shift += 7 {
 11128  				if shift >= 64 {
 11129  					return ErrIntOverflow
 11130  				}
 11131  				if iNdEx >= l {
 11132  					return io.ErrUnexpectedEOF
 11133  				}
 11134  				b := dAtA[iNdEx]
 11135  				iNdEx++
 11136  				msglen |= int(b&0x7F) << shift
 11137  				if b < 0x80 {
 11138  					break
 11139  				}
 11140  			}
 11141  			if msglen < 0 {
 11142  				return ErrInvalidLength
 11143  			}
 11144  			postIndex := iNdEx + msglen
 11145  			if postIndex < 0 {
 11146  				return ErrInvalidLength
 11147  			}
 11148  			if postIndex > l {
 11149  				return io.ErrUnexpectedEOF
 11150  			}
 11151  			if m.Status == nil {
 11152  				m.Status = &replicationdata.PrimaryStatus{}
 11153  			}
 11154  			if err := m.Status.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 11155  				return err
 11156  			}
 11157  			iNdEx = postIndex
 11158  		default:
 11159  			iNdEx = preIndex
 11160  			skippy, err := skip(dAtA[iNdEx:])
 11161  			if err != nil {
 11162  				return err
 11163  			}
 11164  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11165  				return ErrInvalidLength
 11166  			}
 11167  			if (iNdEx + skippy) > l {
 11168  				return io.ErrUnexpectedEOF
 11169  			}
 11170  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11171  			iNdEx += skippy
 11172  		}
 11173  	}
 11174  
 11175  	if iNdEx > l {
 11176  		return io.ErrUnexpectedEOF
 11177  	}
 11178  	return nil
 11179  }
 11180  func (m *PrimaryPositionRequest) UnmarshalVT(dAtA []byte) error {
 11181  	l := len(dAtA)
 11182  	iNdEx := 0
 11183  	for iNdEx < l {
 11184  		preIndex := iNdEx
 11185  		var wire uint64
 11186  		for shift := uint(0); ; shift += 7 {
 11187  			if shift >= 64 {
 11188  				return ErrIntOverflow
 11189  			}
 11190  			if iNdEx >= l {
 11191  				return io.ErrUnexpectedEOF
 11192  			}
 11193  			b := dAtA[iNdEx]
 11194  			iNdEx++
 11195  			wire |= uint64(b&0x7F) << shift
 11196  			if b < 0x80 {
 11197  				break
 11198  			}
 11199  		}
 11200  		fieldNum := int32(wire >> 3)
 11201  		wireType := int(wire & 0x7)
 11202  		if wireType == 4 {
 11203  			return fmt.Errorf("proto: PrimaryPositionRequest: wiretype end group for non-group")
 11204  		}
 11205  		if fieldNum <= 0 {
 11206  			return fmt.Errorf("proto: PrimaryPositionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11207  		}
 11208  		switch fieldNum {
 11209  		default:
 11210  			iNdEx = preIndex
 11211  			skippy, err := skip(dAtA[iNdEx:])
 11212  			if err != nil {
 11213  				return err
 11214  			}
 11215  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11216  				return ErrInvalidLength
 11217  			}
 11218  			if (iNdEx + skippy) > l {
 11219  				return io.ErrUnexpectedEOF
 11220  			}
 11221  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11222  			iNdEx += skippy
 11223  		}
 11224  	}
 11225  
 11226  	if iNdEx > l {
 11227  		return io.ErrUnexpectedEOF
 11228  	}
 11229  	return nil
 11230  }
 11231  func (m *PrimaryPositionResponse) UnmarshalVT(dAtA []byte) error {
 11232  	l := len(dAtA)
 11233  	iNdEx := 0
 11234  	for iNdEx < l {
 11235  		preIndex := iNdEx
 11236  		var wire uint64
 11237  		for shift := uint(0); ; shift += 7 {
 11238  			if shift >= 64 {
 11239  				return ErrIntOverflow
 11240  			}
 11241  			if iNdEx >= l {
 11242  				return io.ErrUnexpectedEOF
 11243  			}
 11244  			b := dAtA[iNdEx]
 11245  			iNdEx++
 11246  			wire |= uint64(b&0x7F) << shift
 11247  			if b < 0x80 {
 11248  				break
 11249  			}
 11250  		}
 11251  		fieldNum := int32(wire >> 3)
 11252  		wireType := int(wire & 0x7)
 11253  		if wireType == 4 {
 11254  			return fmt.Errorf("proto: PrimaryPositionResponse: wiretype end group for non-group")
 11255  		}
 11256  		if fieldNum <= 0 {
 11257  			return fmt.Errorf("proto: PrimaryPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11258  		}
 11259  		switch fieldNum {
 11260  		case 1:
 11261  			if wireType != 2 {
 11262  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 11263  			}
 11264  			var stringLen uint64
 11265  			for shift := uint(0); ; shift += 7 {
 11266  				if shift >= 64 {
 11267  					return ErrIntOverflow
 11268  				}
 11269  				if iNdEx >= l {
 11270  					return io.ErrUnexpectedEOF
 11271  				}
 11272  				b := dAtA[iNdEx]
 11273  				iNdEx++
 11274  				stringLen |= uint64(b&0x7F) << shift
 11275  				if b < 0x80 {
 11276  					break
 11277  				}
 11278  			}
 11279  			intStringLen := int(stringLen)
 11280  			if intStringLen < 0 {
 11281  				return ErrInvalidLength
 11282  			}
 11283  			postIndex := iNdEx + intStringLen
 11284  			if postIndex < 0 {
 11285  				return ErrInvalidLength
 11286  			}
 11287  			if postIndex > l {
 11288  				return io.ErrUnexpectedEOF
 11289  			}
 11290  			m.Position = string(dAtA[iNdEx:postIndex])
 11291  			iNdEx = postIndex
 11292  		default:
 11293  			iNdEx = preIndex
 11294  			skippy, err := skip(dAtA[iNdEx:])
 11295  			if err != nil {
 11296  				return err
 11297  			}
 11298  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11299  				return ErrInvalidLength
 11300  			}
 11301  			if (iNdEx + skippy) > l {
 11302  				return io.ErrUnexpectedEOF
 11303  			}
 11304  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11305  			iNdEx += skippy
 11306  		}
 11307  	}
 11308  
 11309  	if iNdEx > l {
 11310  		return io.ErrUnexpectedEOF
 11311  	}
 11312  	return nil
 11313  }
 11314  func (m *WaitForPositionRequest) UnmarshalVT(dAtA []byte) error {
 11315  	l := len(dAtA)
 11316  	iNdEx := 0
 11317  	for iNdEx < l {
 11318  		preIndex := iNdEx
 11319  		var wire uint64
 11320  		for shift := uint(0); ; shift += 7 {
 11321  			if shift >= 64 {
 11322  				return ErrIntOverflow
 11323  			}
 11324  			if iNdEx >= l {
 11325  				return io.ErrUnexpectedEOF
 11326  			}
 11327  			b := dAtA[iNdEx]
 11328  			iNdEx++
 11329  			wire |= uint64(b&0x7F) << shift
 11330  			if b < 0x80 {
 11331  				break
 11332  			}
 11333  		}
 11334  		fieldNum := int32(wire >> 3)
 11335  		wireType := int(wire & 0x7)
 11336  		if wireType == 4 {
 11337  			return fmt.Errorf("proto: WaitForPositionRequest: wiretype end group for non-group")
 11338  		}
 11339  		if fieldNum <= 0 {
 11340  			return fmt.Errorf("proto: WaitForPositionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11341  		}
 11342  		switch fieldNum {
 11343  		case 1:
 11344  			if wireType != 2 {
 11345  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 11346  			}
 11347  			var stringLen uint64
 11348  			for shift := uint(0); ; shift += 7 {
 11349  				if shift >= 64 {
 11350  					return ErrIntOverflow
 11351  				}
 11352  				if iNdEx >= l {
 11353  					return io.ErrUnexpectedEOF
 11354  				}
 11355  				b := dAtA[iNdEx]
 11356  				iNdEx++
 11357  				stringLen |= uint64(b&0x7F) << shift
 11358  				if b < 0x80 {
 11359  					break
 11360  				}
 11361  			}
 11362  			intStringLen := int(stringLen)
 11363  			if intStringLen < 0 {
 11364  				return ErrInvalidLength
 11365  			}
 11366  			postIndex := iNdEx + intStringLen
 11367  			if postIndex < 0 {
 11368  				return ErrInvalidLength
 11369  			}
 11370  			if postIndex > l {
 11371  				return io.ErrUnexpectedEOF
 11372  			}
 11373  			m.Position = string(dAtA[iNdEx:postIndex])
 11374  			iNdEx = postIndex
 11375  		default:
 11376  			iNdEx = preIndex
 11377  			skippy, err := skip(dAtA[iNdEx:])
 11378  			if err != nil {
 11379  				return err
 11380  			}
 11381  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11382  				return ErrInvalidLength
 11383  			}
 11384  			if (iNdEx + skippy) > l {
 11385  				return io.ErrUnexpectedEOF
 11386  			}
 11387  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11388  			iNdEx += skippy
 11389  		}
 11390  	}
 11391  
 11392  	if iNdEx > l {
 11393  		return io.ErrUnexpectedEOF
 11394  	}
 11395  	return nil
 11396  }
 11397  func (m *WaitForPositionResponse) UnmarshalVT(dAtA []byte) error {
 11398  	l := len(dAtA)
 11399  	iNdEx := 0
 11400  	for iNdEx < l {
 11401  		preIndex := iNdEx
 11402  		var wire uint64
 11403  		for shift := uint(0); ; shift += 7 {
 11404  			if shift >= 64 {
 11405  				return ErrIntOverflow
 11406  			}
 11407  			if iNdEx >= l {
 11408  				return io.ErrUnexpectedEOF
 11409  			}
 11410  			b := dAtA[iNdEx]
 11411  			iNdEx++
 11412  			wire |= uint64(b&0x7F) << shift
 11413  			if b < 0x80 {
 11414  				break
 11415  			}
 11416  		}
 11417  		fieldNum := int32(wire >> 3)
 11418  		wireType := int(wire & 0x7)
 11419  		if wireType == 4 {
 11420  			return fmt.Errorf("proto: WaitForPositionResponse: wiretype end group for non-group")
 11421  		}
 11422  		if fieldNum <= 0 {
 11423  			return fmt.Errorf("proto: WaitForPositionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11424  		}
 11425  		switch fieldNum {
 11426  		default:
 11427  			iNdEx = preIndex
 11428  			skippy, err := skip(dAtA[iNdEx:])
 11429  			if err != nil {
 11430  				return err
 11431  			}
 11432  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11433  				return ErrInvalidLength
 11434  			}
 11435  			if (iNdEx + skippy) > l {
 11436  				return io.ErrUnexpectedEOF
 11437  			}
 11438  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11439  			iNdEx += skippy
 11440  		}
 11441  	}
 11442  
 11443  	if iNdEx > l {
 11444  		return io.ErrUnexpectedEOF
 11445  	}
 11446  	return nil
 11447  }
 11448  func (m *StopReplicationRequest) UnmarshalVT(dAtA []byte) error {
 11449  	l := len(dAtA)
 11450  	iNdEx := 0
 11451  	for iNdEx < l {
 11452  		preIndex := iNdEx
 11453  		var wire uint64
 11454  		for shift := uint(0); ; shift += 7 {
 11455  			if shift >= 64 {
 11456  				return ErrIntOverflow
 11457  			}
 11458  			if iNdEx >= l {
 11459  				return io.ErrUnexpectedEOF
 11460  			}
 11461  			b := dAtA[iNdEx]
 11462  			iNdEx++
 11463  			wire |= uint64(b&0x7F) << shift
 11464  			if b < 0x80 {
 11465  				break
 11466  			}
 11467  		}
 11468  		fieldNum := int32(wire >> 3)
 11469  		wireType := int(wire & 0x7)
 11470  		if wireType == 4 {
 11471  			return fmt.Errorf("proto: StopReplicationRequest: wiretype end group for non-group")
 11472  		}
 11473  		if fieldNum <= 0 {
 11474  			return fmt.Errorf("proto: StopReplicationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11475  		}
 11476  		switch fieldNum {
 11477  		default:
 11478  			iNdEx = preIndex
 11479  			skippy, err := skip(dAtA[iNdEx:])
 11480  			if err != nil {
 11481  				return err
 11482  			}
 11483  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11484  				return ErrInvalidLength
 11485  			}
 11486  			if (iNdEx + skippy) > l {
 11487  				return io.ErrUnexpectedEOF
 11488  			}
 11489  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11490  			iNdEx += skippy
 11491  		}
 11492  	}
 11493  
 11494  	if iNdEx > l {
 11495  		return io.ErrUnexpectedEOF
 11496  	}
 11497  	return nil
 11498  }
 11499  func (m *StopReplicationResponse) UnmarshalVT(dAtA []byte) error {
 11500  	l := len(dAtA)
 11501  	iNdEx := 0
 11502  	for iNdEx < l {
 11503  		preIndex := iNdEx
 11504  		var wire uint64
 11505  		for shift := uint(0); ; shift += 7 {
 11506  			if shift >= 64 {
 11507  				return ErrIntOverflow
 11508  			}
 11509  			if iNdEx >= l {
 11510  				return io.ErrUnexpectedEOF
 11511  			}
 11512  			b := dAtA[iNdEx]
 11513  			iNdEx++
 11514  			wire |= uint64(b&0x7F) << shift
 11515  			if b < 0x80 {
 11516  				break
 11517  			}
 11518  		}
 11519  		fieldNum := int32(wire >> 3)
 11520  		wireType := int(wire & 0x7)
 11521  		if wireType == 4 {
 11522  			return fmt.Errorf("proto: StopReplicationResponse: wiretype end group for non-group")
 11523  		}
 11524  		if fieldNum <= 0 {
 11525  			return fmt.Errorf("proto: StopReplicationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11526  		}
 11527  		switch fieldNum {
 11528  		default:
 11529  			iNdEx = preIndex
 11530  			skippy, err := skip(dAtA[iNdEx:])
 11531  			if err != nil {
 11532  				return err
 11533  			}
 11534  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11535  				return ErrInvalidLength
 11536  			}
 11537  			if (iNdEx + skippy) > l {
 11538  				return io.ErrUnexpectedEOF
 11539  			}
 11540  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11541  			iNdEx += skippy
 11542  		}
 11543  	}
 11544  
 11545  	if iNdEx > l {
 11546  		return io.ErrUnexpectedEOF
 11547  	}
 11548  	return nil
 11549  }
 11550  func (m *StopReplicationMinimumRequest) UnmarshalVT(dAtA []byte) error {
 11551  	l := len(dAtA)
 11552  	iNdEx := 0
 11553  	for iNdEx < l {
 11554  		preIndex := iNdEx
 11555  		var wire uint64
 11556  		for shift := uint(0); ; shift += 7 {
 11557  			if shift >= 64 {
 11558  				return ErrIntOverflow
 11559  			}
 11560  			if iNdEx >= l {
 11561  				return io.ErrUnexpectedEOF
 11562  			}
 11563  			b := dAtA[iNdEx]
 11564  			iNdEx++
 11565  			wire |= uint64(b&0x7F) << shift
 11566  			if b < 0x80 {
 11567  				break
 11568  			}
 11569  		}
 11570  		fieldNum := int32(wire >> 3)
 11571  		wireType := int(wire & 0x7)
 11572  		if wireType == 4 {
 11573  			return fmt.Errorf("proto: StopReplicationMinimumRequest: wiretype end group for non-group")
 11574  		}
 11575  		if fieldNum <= 0 {
 11576  			return fmt.Errorf("proto: StopReplicationMinimumRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11577  		}
 11578  		switch fieldNum {
 11579  		case 1:
 11580  			if wireType != 2 {
 11581  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 11582  			}
 11583  			var stringLen uint64
 11584  			for shift := uint(0); ; shift += 7 {
 11585  				if shift >= 64 {
 11586  					return ErrIntOverflow
 11587  				}
 11588  				if iNdEx >= l {
 11589  					return io.ErrUnexpectedEOF
 11590  				}
 11591  				b := dAtA[iNdEx]
 11592  				iNdEx++
 11593  				stringLen |= uint64(b&0x7F) << shift
 11594  				if b < 0x80 {
 11595  					break
 11596  				}
 11597  			}
 11598  			intStringLen := int(stringLen)
 11599  			if intStringLen < 0 {
 11600  				return ErrInvalidLength
 11601  			}
 11602  			postIndex := iNdEx + intStringLen
 11603  			if postIndex < 0 {
 11604  				return ErrInvalidLength
 11605  			}
 11606  			if postIndex > l {
 11607  				return io.ErrUnexpectedEOF
 11608  			}
 11609  			m.Position = string(dAtA[iNdEx:postIndex])
 11610  			iNdEx = postIndex
 11611  		case 2:
 11612  			if wireType != 0 {
 11613  				return fmt.Errorf("proto: wrong wireType = %d for field WaitTimeout", wireType)
 11614  			}
 11615  			m.WaitTimeout = 0
 11616  			for shift := uint(0); ; shift += 7 {
 11617  				if shift >= 64 {
 11618  					return ErrIntOverflow
 11619  				}
 11620  				if iNdEx >= l {
 11621  					return io.ErrUnexpectedEOF
 11622  				}
 11623  				b := dAtA[iNdEx]
 11624  				iNdEx++
 11625  				m.WaitTimeout |= int64(b&0x7F) << shift
 11626  				if b < 0x80 {
 11627  					break
 11628  				}
 11629  			}
 11630  		default:
 11631  			iNdEx = preIndex
 11632  			skippy, err := skip(dAtA[iNdEx:])
 11633  			if err != nil {
 11634  				return err
 11635  			}
 11636  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11637  				return ErrInvalidLength
 11638  			}
 11639  			if (iNdEx + skippy) > l {
 11640  				return io.ErrUnexpectedEOF
 11641  			}
 11642  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11643  			iNdEx += skippy
 11644  		}
 11645  	}
 11646  
 11647  	if iNdEx > l {
 11648  		return io.ErrUnexpectedEOF
 11649  	}
 11650  	return nil
 11651  }
 11652  func (m *StopReplicationMinimumResponse) UnmarshalVT(dAtA []byte) error {
 11653  	l := len(dAtA)
 11654  	iNdEx := 0
 11655  	for iNdEx < l {
 11656  		preIndex := iNdEx
 11657  		var wire uint64
 11658  		for shift := uint(0); ; shift += 7 {
 11659  			if shift >= 64 {
 11660  				return ErrIntOverflow
 11661  			}
 11662  			if iNdEx >= l {
 11663  				return io.ErrUnexpectedEOF
 11664  			}
 11665  			b := dAtA[iNdEx]
 11666  			iNdEx++
 11667  			wire |= uint64(b&0x7F) << shift
 11668  			if b < 0x80 {
 11669  				break
 11670  			}
 11671  		}
 11672  		fieldNum := int32(wire >> 3)
 11673  		wireType := int(wire & 0x7)
 11674  		if wireType == 4 {
 11675  			return fmt.Errorf("proto: StopReplicationMinimumResponse: wiretype end group for non-group")
 11676  		}
 11677  		if fieldNum <= 0 {
 11678  			return fmt.Errorf("proto: StopReplicationMinimumResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11679  		}
 11680  		switch fieldNum {
 11681  		case 1:
 11682  			if wireType != 2 {
 11683  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 11684  			}
 11685  			var stringLen uint64
 11686  			for shift := uint(0); ; shift += 7 {
 11687  				if shift >= 64 {
 11688  					return ErrIntOverflow
 11689  				}
 11690  				if iNdEx >= l {
 11691  					return io.ErrUnexpectedEOF
 11692  				}
 11693  				b := dAtA[iNdEx]
 11694  				iNdEx++
 11695  				stringLen |= uint64(b&0x7F) << shift
 11696  				if b < 0x80 {
 11697  					break
 11698  				}
 11699  			}
 11700  			intStringLen := int(stringLen)
 11701  			if intStringLen < 0 {
 11702  				return ErrInvalidLength
 11703  			}
 11704  			postIndex := iNdEx + intStringLen
 11705  			if postIndex < 0 {
 11706  				return ErrInvalidLength
 11707  			}
 11708  			if postIndex > l {
 11709  				return io.ErrUnexpectedEOF
 11710  			}
 11711  			m.Position = string(dAtA[iNdEx:postIndex])
 11712  			iNdEx = postIndex
 11713  		default:
 11714  			iNdEx = preIndex
 11715  			skippy, err := skip(dAtA[iNdEx:])
 11716  			if err != nil {
 11717  				return err
 11718  			}
 11719  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11720  				return ErrInvalidLength
 11721  			}
 11722  			if (iNdEx + skippy) > l {
 11723  				return io.ErrUnexpectedEOF
 11724  			}
 11725  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11726  			iNdEx += skippy
 11727  		}
 11728  	}
 11729  
 11730  	if iNdEx > l {
 11731  		return io.ErrUnexpectedEOF
 11732  	}
 11733  	return nil
 11734  }
 11735  func (m *StartReplicationRequest) UnmarshalVT(dAtA []byte) error {
 11736  	l := len(dAtA)
 11737  	iNdEx := 0
 11738  	for iNdEx < l {
 11739  		preIndex := iNdEx
 11740  		var wire uint64
 11741  		for shift := uint(0); ; shift += 7 {
 11742  			if shift >= 64 {
 11743  				return ErrIntOverflow
 11744  			}
 11745  			if iNdEx >= l {
 11746  				return io.ErrUnexpectedEOF
 11747  			}
 11748  			b := dAtA[iNdEx]
 11749  			iNdEx++
 11750  			wire |= uint64(b&0x7F) << shift
 11751  			if b < 0x80 {
 11752  				break
 11753  			}
 11754  		}
 11755  		fieldNum := int32(wire >> 3)
 11756  		wireType := int(wire & 0x7)
 11757  		if wireType == 4 {
 11758  			return fmt.Errorf("proto: StartReplicationRequest: wiretype end group for non-group")
 11759  		}
 11760  		if fieldNum <= 0 {
 11761  			return fmt.Errorf("proto: StartReplicationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11762  		}
 11763  		switch fieldNum {
 11764  		case 1:
 11765  			if wireType != 0 {
 11766  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
 11767  			}
 11768  			var v int
 11769  			for shift := uint(0); ; shift += 7 {
 11770  				if shift >= 64 {
 11771  					return ErrIntOverflow
 11772  				}
 11773  				if iNdEx >= l {
 11774  					return io.ErrUnexpectedEOF
 11775  				}
 11776  				b := dAtA[iNdEx]
 11777  				iNdEx++
 11778  				v |= int(b&0x7F) << shift
 11779  				if b < 0x80 {
 11780  					break
 11781  				}
 11782  			}
 11783  			m.SemiSync = bool(v != 0)
 11784  		default:
 11785  			iNdEx = preIndex
 11786  			skippy, err := skip(dAtA[iNdEx:])
 11787  			if err != nil {
 11788  				return err
 11789  			}
 11790  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11791  				return ErrInvalidLength
 11792  			}
 11793  			if (iNdEx + skippy) > l {
 11794  				return io.ErrUnexpectedEOF
 11795  			}
 11796  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11797  			iNdEx += skippy
 11798  		}
 11799  	}
 11800  
 11801  	if iNdEx > l {
 11802  		return io.ErrUnexpectedEOF
 11803  	}
 11804  	return nil
 11805  }
 11806  func (m *StartReplicationResponse) UnmarshalVT(dAtA []byte) error {
 11807  	l := len(dAtA)
 11808  	iNdEx := 0
 11809  	for iNdEx < l {
 11810  		preIndex := iNdEx
 11811  		var wire uint64
 11812  		for shift := uint(0); ; shift += 7 {
 11813  			if shift >= 64 {
 11814  				return ErrIntOverflow
 11815  			}
 11816  			if iNdEx >= l {
 11817  				return io.ErrUnexpectedEOF
 11818  			}
 11819  			b := dAtA[iNdEx]
 11820  			iNdEx++
 11821  			wire |= uint64(b&0x7F) << shift
 11822  			if b < 0x80 {
 11823  				break
 11824  			}
 11825  		}
 11826  		fieldNum := int32(wire >> 3)
 11827  		wireType := int(wire & 0x7)
 11828  		if wireType == 4 {
 11829  			return fmt.Errorf("proto: StartReplicationResponse: wiretype end group for non-group")
 11830  		}
 11831  		if fieldNum <= 0 {
 11832  			return fmt.Errorf("proto: StartReplicationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11833  		}
 11834  		switch fieldNum {
 11835  		default:
 11836  			iNdEx = preIndex
 11837  			skippy, err := skip(dAtA[iNdEx:])
 11838  			if err != nil {
 11839  				return err
 11840  			}
 11841  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11842  				return ErrInvalidLength
 11843  			}
 11844  			if (iNdEx + skippy) > l {
 11845  				return io.ErrUnexpectedEOF
 11846  			}
 11847  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11848  			iNdEx += skippy
 11849  		}
 11850  	}
 11851  
 11852  	if iNdEx > l {
 11853  		return io.ErrUnexpectedEOF
 11854  	}
 11855  	return nil
 11856  }
 11857  func (m *StartReplicationUntilAfterRequest) UnmarshalVT(dAtA []byte) error {
 11858  	l := len(dAtA)
 11859  	iNdEx := 0
 11860  	for iNdEx < l {
 11861  		preIndex := iNdEx
 11862  		var wire uint64
 11863  		for shift := uint(0); ; shift += 7 {
 11864  			if shift >= 64 {
 11865  				return ErrIntOverflow
 11866  			}
 11867  			if iNdEx >= l {
 11868  				return io.ErrUnexpectedEOF
 11869  			}
 11870  			b := dAtA[iNdEx]
 11871  			iNdEx++
 11872  			wire |= uint64(b&0x7F) << shift
 11873  			if b < 0x80 {
 11874  				break
 11875  			}
 11876  		}
 11877  		fieldNum := int32(wire >> 3)
 11878  		wireType := int(wire & 0x7)
 11879  		if wireType == 4 {
 11880  			return fmt.Errorf("proto: StartReplicationUntilAfterRequest: wiretype end group for non-group")
 11881  		}
 11882  		if fieldNum <= 0 {
 11883  			return fmt.Errorf("proto: StartReplicationUntilAfterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 11884  		}
 11885  		switch fieldNum {
 11886  		case 1:
 11887  			if wireType != 2 {
 11888  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 11889  			}
 11890  			var stringLen uint64
 11891  			for shift := uint(0); ; shift += 7 {
 11892  				if shift >= 64 {
 11893  					return ErrIntOverflow
 11894  				}
 11895  				if iNdEx >= l {
 11896  					return io.ErrUnexpectedEOF
 11897  				}
 11898  				b := dAtA[iNdEx]
 11899  				iNdEx++
 11900  				stringLen |= uint64(b&0x7F) << shift
 11901  				if b < 0x80 {
 11902  					break
 11903  				}
 11904  			}
 11905  			intStringLen := int(stringLen)
 11906  			if intStringLen < 0 {
 11907  				return ErrInvalidLength
 11908  			}
 11909  			postIndex := iNdEx + intStringLen
 11910  			if postIndex < 0 {
 11911  				return ErrInvalidLength
 11912  			}
 11913  			if postIndex > l {
 11914  				return io.ErrUnexpectedEOF
 11915  			}
 11916  			m.Position = string(dAtA[iNdEx:postIndex])
 11917  			iNdEx = postIndex
 11918  		case 2:
 11919  			if wireType != 0 {
 11920  				return fmt.Errorf("proto: wrong wireType = %d for field WaitTimeout", wireType)
 11921  			}
 11922  			m.WaitTimeout = 0
 11923  			for shift := uint(0); ; shift += 7 {
 11924  				if shift >= 64 {
 11925  					return ErrIntOverflow
 11926  				}
 11927  				if iNdEx >= l {
 11928  					return io.ErrUnexpectedEOF
 11929  				}
 11930  				b := dAtA[iNdEx]
 11931  				iNdEx++
 11932  				m.WaitTimeout |= int64(b&0x7F) << shift
 11933  				if b < 0x80 {
 11934  					break
 11935  				}
 11936  			}
 11937  		default:
 11938  			iNdEx = preIndex
 11939  			skippy, err := skip(dAtA[iNdEx:])
 11940  			if err != nil {
 11941  				return err
 11942  			}
 11943  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11944  				return ErrInvalidLength
 11945  			}
 11946  			if (iNdEx + skippy) > l {
 11947  				return io.ErrUnexpectedEOF
 11948  			}
 11949  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 11950  			iNdEx += skippy
 11951  		}
 11952  	}
 11953  
 11954  	if iNdEx > l {
 11955  		return io.ErrUnexpectedEOF
 11956  	}
 11957  	return nil
 11958  }
 11959  func (m *StartReplicationUntilAfterResponse) UnmarshalVT(dAtA []byte) error {
 11960  	l := len(dAtA)
 11961  	iNdEx := 0
 11962  	for iNdEx < l {
 11963  		preIndex := iNdEx
 11964  		var wire uint64
 11965  		for shift := uint(0); ; shift += 7 {
 11966  			if shift >= 64 {
 11967  				return ErrIntOverflow
 11968  			}
 11969  			if iNdEx >= l {
 11970  				return io.ErrUnexpectedEOF
 11971  			}
 11972  			b := dAtA[iNdEx]
 11973  			iNdEx++
 11974  			wire |= uint64(b&0x7F) << shift
 11975  			if b < 0x80 {
 11976  				break
 11977  			}
 11978  		}
 11979  		fieldNum := int32(wire >> 3)
 11980  		wireType := int(wire & 0x7)
 11981  		if wireType == 4 {
 11982  			return fmt.Errorf("proto: StartReplicationUntilAfterResponse: wiretype end group for non-group")
 11983  		}
 11984  		if fieldNum <= 0 {
 11985  			return fmt.Errorf("proto: StartReplicationUntilAfterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 11986  		}
 11987  		switch fieldNum {
 11988  		default:
 11989  			iNdEx = preIndex
 11990  			skippy, err := skip(dAtA[iNdEx:])
 11991  			if err != nil {
 11992  				return err
 11993  			}
 11994  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11995  				return ErrInvalidLength
 11996  			}
 11997  			if (iNdEx + skippy) > l {
 11998  				return io.ErrUnexpectedEOF
 11999  			}
 12000  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12001  			iNdEx += skippy
 12002  		}
 12003  	}
 12004  
 12005  	if iNdEx > l {
 12006  		return io.ErrUnexpectedEOF
 12007  	}
 12008  	return nil
 12009  }
 12010  func (m *GetReplicasRequest) UnmarshalVT(dAtA []byte) error {
 12011  	l := len(dAtA)
 12012  	iNdEx := 0
 12013  	for iNdEx < l {
 12014  		preIndex := iNdEx
 12015  		var wire uint64
 12016  		for shift := uint(0); ; shift += 7 {
 12017  			if shift >= 64 {
 12018  				return ErrIntOverflow
 12019  			}
 12020  			if iNdEx >= l {
 12021  				return io.ErrUnexpectedEOF
 12022  			}
 12023  			b := dAtA[iNdEx]
 12024  			iNdEx++
 12025  			wire |= uint64(b&0x7F) << shift
 12026  			if b < 0x80 {
 12027  				break
 12028  			}
 12029  		}
 12030  		fieldNum := int32(wire >> 3)
 12031  		wireType := int(wire & 0x7)
 12032  		if wireType == 4 {
 12033  			return fmt.Errorf("proto: GetReplicasRequest: wiretype end group for non-group")
 12034  		}
 12035  		if fieldNum <= 0 {
 12036  			return fmt.Errorf("proto: GetReplicasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12037  		}
 12038  		switch fieldNum {
 12039  		default:
 12040  			iNdEx = preIndex
 12041  			skippy, err := skip(dAtA[iNdEx:])
 12042  			if err != nil {
 12043  				return err
 12044  			}
 12045  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12046  				return ErrInvalidLength
 12047  			}
 12048  			if (iNdEx + skippy) > l {
 12049  				return io.ErrUnexpectedEOF
 12050  			}
 12051  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12052  			iNdEx += skippy
 12053  		}
 12054  	}
 12055  
 12056  	if iNdEx > l {
 12057  		return io.ErrUnexpectedEOF
 12058  	}
 12059  	return nil
 12060  }
 12061  func (m *GetReplicasResponse) UnmarshalVT(dAtA []byte) error {
 12062  	l := len(dAtA)
 12063  	iNdEx := 0
 12064  	for iNdEx < l {
 12065  		preIndex := iNdEx
 12066  		var wire uint64
 12067  		for shift := uint(0); ; shift += 7 {
 12068  			if shift >= 64 {
 12069  				return ErrIntOverflow
 12070  			}
 12071  			if iNdEx >= l {
 12072  				return io.ErrUnexpectedEOF
 12073  			}
 12074  			b := dAtA[iNdEx]
 12075  			iNdEx++
 12076  			wire |= uint64(b&0x7F) << shift
 12077  			if b < 0x80 {
 12078  				break
 12079  			}
 12080  		}
 12081  		fieldNum := int32(wire >> 3)
 12082  		wireType := int(wire & 0x7)
 12083  		if wireType == 4 {
 12084  			return fmt.Errorf("proto: GetReplicasResponse: wiretype end group for non-group")
 12085  		}
 12086  		if fieldNum <= 0 {
 12087  			return fmt.Errorf("proto: GetReplicasResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12088  		}
 12089  		switch fieldNum {
 12090  		case 1:
 12091  			if wireType != 2 {
 12092  				return fmt.Errorf("proto: wrong wireType = %d for field Addrs", wireType)
 12093  			}
 12094  			var stringLen uint64
 12095  			for shift := uint(0); ; shift += 7 {
 12096  				if shift >= 64 {
 12097  					return ErrIntOverflow
 12098  				}
 12099  				if iNdEx >= l {
 12100  					return io.ErrUnexpectedEOF
 12101  				}
 12102  				b := dAtA[iNdEx]
 12103  				iNdEx++
 12104  				stringLen |= uint64(b&0x7F) << shift
 12105  				if b < 0x80 {
 12106  					break
 12107  				}
 12108  			}
 12109  			intStringLen := int(stringLen)
 12110  			if intStringLen < 0 {
 12111  				return ErrInvalidLength
 12112  			}
 12113  			postIndex := iNdEx + intStringLen
 12114  			if postIndex < 0 {
 12115  				return ErrInvalidLength
 12116  			}
 12117  			if postIndex > l {
 12118  				return io.ErrUnexpectedEOF
 12119  			}
 12120  			m.Addrs = append(m.Addrs, string(dAtA[iNdEx:postIndex]))
 12121  			iNdEx = postIndex
 12122  		default:
 12123  			iNdEx = preIndex
 12124  			skippy, err := skip(dAtA[iNdEx:])
 12125  			if err != nil {
 12126  				return err
 12127  			}
 12128  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12129  				return ErrInvalidLength
 12130  			}
 12131  			if (iNdEx + skippy) > l {
 12132  				return io.ErrUnexpectedEOF
 12133  			}
 12134  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12135  			iNdEx += skippy
 12136  		}
 12137  	}
 12138  
 12139  	if iNdEx > l {
 12140  		return io.ErrUnexpectedEOF
 12141  	}
 12142  	return nil
 12143  }
 12144  func (m *ResetReplicationRequest) UnmarshalVT(dAtA []byte) error {
 12145  	l := len(dAtA)
 12146  	iNdEx := 0
 12147  	for iNdEx < l {
 12148  		preIndex := iNdEx
 12149  		var wire uint64
 12150  		for shift := uint(0); ; shift += 7 {
 12151  			if shift >= 64 {
 12152  				return ErrIntOverflow
 12153  			}
 12154  			if iNdEx >= l {
 12155  				return io.ErrUnexpectedEOF
 12156  			}
 12157  			b := dAtA[iNdEx]
 12158  			iNdEx++
 12159  			wire |= uint64(b&0x7F) << shift
 12160  			if b < 0x80 {
 12161  				break
 12162  			}
 12163  		}
 12164  		fieldNum := int32(wire >> 3)
 12165  		wireType := int(wire & 0x7)
 12166  		if wireType == 4 {
 12167  			return fmt.Errorf("proto: ResetReplicationRequest: wiretype end group for non-group")
 12168  		}
 12169  		if fieldNum <= 0 {
 12170  			return fmt.Errorf("proto: ResetReplicationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12171  		}
 12172  		switch fieldNum {
 12173  		default:
 12174  			iNdEx = preIndex
 12175  			skippy, err := skip(dAtA[iNdEx:])
 12176  			if err != nil {
 12177  				return err
 12178  			}
 12179  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12180  				return ErrInvalidLength
 12181  			}
 12182  			if (iNdEx + skippy) > l {
 12183  				return io.ErrUnexpectedEOF
 12184  			}
 12185  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12186  			iNdEx += skippy
 12187  		}
 12188  	}
 12189  
 12190  	if iNdEx > l {
 12191  		return io.ErrUnexpectedEOF
 12192  	}
 12193  	return nil
 12194  }
 12195  func (m *ResetReplicationResponse) UnmarshalVT(dAtA []byte) error {
 12196  	l := len(dAtA)
 12197  	iNdEx := 0
 12198  	for iNdEx < l {
 12199  		preIndex := iNdEx
 12200  		var wire uint64
 12201  		for shift := uint(0); ; shift += 7 {
 12202  			if shift >= 64 {
 12203  				return ErrIntOverflow
 12204  			}
 12205  			if iNdEx >= l {
 12206  				return io.ErrUnexpectedEOF
 12207  			}
 12208  			b := dAtA[iNdEx]
 12209  			iNdEx++
 12210  			wire |= uint64(b&0x7F) << shift
 12211  			if b < 0x80 {
 12212  				break
 12213  			}
 12214  		}
 12215  		fieldNum := int32(wire >> 3)
 12216  		wireType := int(wire & 0x7)
 12217  		if wireType == 4 {
 12218  			return fmt.Errorf("proto: ResetReplicationResponse: wiretype end group for non-group")
 12219  		}
 12220  		if fieldNum <= 0 {
 12221  			return fmt.Errorf("proto: ResetReplicationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12222  		}
 12223  		switch fieldNum {
 12224  		default:
 12225  			iNdEx = preIndex
 12226  			skippy, err := skip(dAtA[iNdEx:])
 12227  			if err != nil {
 12228  				return err
 12229  			}
 12230  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12231  				return ErrInvalidLength
 12232  			}
 12233  			if (iNdEx + skippy) > l {
 12234  				return io.ErrUnexpectedEOF
 12235  			}
 12236  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12237  			iNdEx += skippy
 12238  		}
 12239  	}
 12240  
 12241  	if iNdEx > l {
 12242  		return io.ErrUnexpectedEOF
 12243  	}
 12244  	return nil
 12245  }
 12246  func (m *VReplicationExecRequest) UnmarshalVT(dAtA []byte) error {
 12247  	l := len(dAtA)
 12248  	iNdEx := 0
 12249  	for iNdEx < l {
 12250  		preIndex := iNdEx
 12251  		var wire uint64
 12252  		for shift := uint(0); ; shift += 7 {
 12253  			if shift >= 64 {
 12254  				return ErrIntOverflow
 12255  			}
 12256  			if iNdEx >= l {
 12257  				return io.ErrUnexpectedEOF
 12258  			}
 12259  			b := dAtA[iNdEx]
 12260  			iNdEx++
 12261  			wire |= uint64(b&0x7F) << shift
 12262  			if b < 0x80 {
 12263  				break
 12264  			}
 12265  		}
 12266  		fieldNum := int32(wire >> 3)
 12267  		wireType := int(wire & 0x7)
 12268  		if wireType == 4 {
 12269  			return fmt.Errorf("proto: VReplicationExecRequest: wiretype end group for non-group")
 12270  		}
 12271  		if fieldNum <= 0 {
 12272  			return fmt.Errorf("proto: VReplicationExecRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12273  		}
 12274  		switch fieldNum {
 12275  		case 1:
 12276  			if wireType != 2 {
 12277  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 12278  			}
 12279  			var stringLen uint64
 12280  			for shift := uint(0); ; shift += 7 {
 12281  				if shift >= 64 {
 12282  					return ErrIntOverflow
 12283  				}
 12284  				if iNdEx >= l {
 12285  					return io.ErrUnexpectedEOF
 12286  				}
 12287  				b := dAtA[iNdEx]
 12288  				iNdEx++
 12289  				stringLen |= uint64(b&0x7F) << shift
 12290  				if b < 0x80 {
 12291  					break
 12292  				}
 12293  			}
 12294  			intStringLen := int(stringLen)
 12295  			if intStringLen < 0 {
 12296  				return ErrInvalidLength
 12297  			}
 12298  			postIndex := iNdEx + intStringLen
 12299  			if postIndex < 0 {
 12300  				return ErrInvalidLength
 12301  			}
 12302  			if postIndex > l {
 12303  				return io.ErrUnexpectedEOF
 12304  			}
 12305  			m.Query = string(dAtA[iNdEx:postIndex])
 12306  			iNdEx = postIndex
 12307  		default:
 12308  			iNdEx = preIndex
 12309  			skippy, err := skip(dAtA[iNdEx:])
 12310  			if err != nil {
 12311  				return err
 12312  			}
 12313  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12314  				return ErrInvalidLength
 12315  			}
 12316  			if (iNdEx + skippy) > l {
 12317  				return io.ErrUnexpectedEOF
 12318  			}
 12319  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12320  			iNdEx += skippy
 12321  		}
 12322  	}
 12323  
 12324  	if iNdEx > l {
 12325  		return io.ErrUnexpectedEOF
 12326  	}
 12327  	return nil
 12328  }
 12329  func (m *VReplicationExecResponse) UnmarshalVT(dAtA []byte) error {
 12330  	l := len(dAtA)
 12331  	iNdEx := 0
 12332  	for iNdEx < l {
 12333  		preIndex := iNdEx
 12334  		var wire uint64
 12335  		for shift := uint(0); ; shift += 7 {
 12336  			if shift >= 64 {
 12337  				return ErrIntOverflow
 12338  			}
 12339  			if iNdEx >= l {
 12340  				return io.ErrUnexpectedEOF
 12341  			}
 12342  			b := dAtA[iNdEx]
 12343  			iNdEx++
 12344  			wire |= uint64(b&0x7F) << shift
 12345  			if b < 0x80 {
 12346  				break
 12347  			}
 12348  		}
 12349  		fieldNum := int32(wire >> 3)
 12350  		wireType := int(wire & 0x7)
 12351  		if wireType == 4 {
 12352  			return fmt.Errorf("proto: VReplicationExecResponse: wiretype end group for non-group")
 12353  		}
 12354  		if fieldNum <= 0 {
 12355  			return fmt.Errorf("proto: VReplicationExecResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12356  		}
 12357  		switch fieldNum {
 12358  		case 1:
 12359  			if wireType != 2 {
 12360  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 12361  			}
 12362  			var msglen int
 12363  			for shift := uint(0); ; shift += 7 {
 12364  				if shift >= 64 {
 12365  					return ErrIntOverflow
 12366  				}
 12367  				if iNdEx >= l {
 12368  					return io.ErrUnexpectedEOF
 12369  				}
 12370  				b := dAtA[iNdEx]
 12371  				iNdEx++
 12372  				msglen |= int(b&0x7F) << shift
 12373  				if b < 0x80 {
 12374  					break
 12375  				}
 12376  			}
 12377  			if msglen < 0 {
 12378  				return ErrInvalidLength
 12379  			}
 12380  			postIndex := iNdEx + msglen
 12381  			if postIndex < 0 {
 12382  				return ErrInvalidLength
 12383  			}
 12384  			if postIndex > l {
 12385  				return io.ErrUnexpectedEOF
 12386  			}
 12387  			if m.Result == nil {
 12388  				m.Result = &query.QueryResult{}
 12389  			}
 12390  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12391  				return err
 12392  			}
 12393  			iNdEx = postIndex
 12394  		default:
 12395  			iNdEx = preIndex
 12396  			skippy, err := skip(dAtA[iNdEx:])
 12397  			if err != nil {
 12398  				return err
 12399  			}
 12400  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12401  				return ErrInvalidLength
 12402  			}
 12403  			if (iNdEx + skippy) > l {
 12404  				return io.ErrUnexpectedEOF
 12405  			}
 12406  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12407  			iNdEx += skippy
 12408  		}
 12409  	}
 12410  
 12411  	if iNdEx > l {
 12412  		return io.ErrUnexpectedEOF
 12413  	}
 12414  	return nil
 12415  }
 12416  func (m *VReplicationWaitForPosRequest) UnmarshalVT(dAtA []byte) error {
 12417  	l := len(dAtA)
 12418  	iNdEx := 0
 12419  	for iNdEx < l {
 12420  		preIndex := iNdEx
 12421  		var wire uint64
 12422  		for shift := uint(0); ; shift += 7 {
 12423  			if shift >= 64 {
 12424  				return ErrIntOverflow
 12425  			}
 12426  			if iNdEx >= l {
 12427  				return io.ErrUnexpectedEOF
 12428  			}
 12429  			b := dAtA[iNdEx]
 12430  			iNdEx++
 12431  			wire |= uint64(b&0x7F) << shift
 12432  			if b < 0x80 {
 12433  				break
 12434  			}
 12435  		}
 12436  		fieldNum := int32(wire >> 3)
 12437  		wireType := int(wire & 0x7)
 12438  		if wireType == 4 {
 12439  			return fmt.Errorf("proto: VReplicationWaitForPosRequest: wiretype end group for non-group")
 12440  		}
 12441  		if fieldNum <= 0 {
 12442  			return fmt.Errorf("proto: VReplicationWaitForPosRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12443  		}
 12444  		switch fieldNum {
 12445  		case 1:
 12446  			if wireType != 0 {
 12447  				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
 12448  			}
 12449  			m.Id = 0
 12450  			for shift := uint(0); ; shift += 7 {
 12451  				if shift >= 64 {
 12452  					return ErrIntOverflow
 12453  				}
 12454  				if iNdEx >= l {
 12455  					return io.ErrUnexpectedEOF
 12456  				}
 12457  				b := dAtA[iNdEx]
 12458  				iNdEx++
 12459  				m.Id |= int64(b&0x7F) << shift
 12460  				if b < 0x80 {
 12461  					break
 12462  				}
 12463  			}
 12464  		case 2:
 12465  			if wireType != 2 {
 12466  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 12467  			}
 12468  			var stringLen uint64
 12469  			for shift := uint(0); ; shift += 7 {
 12470  				if shift >= 64 {
 12471  					return ErrIntOverflow
 12472  				}
 12473  				if iNdEx >= l {
 12474  					return io.ErrUnexpectedEOF
 12475  				}
 12476  				b := dAtA[iNdEx]
 12477  				iNdEx++
 12478  				stringLen |= uint64(b&0x7F) << shift
 12479  				if b < 0x80 {
 12480  					break
 12481  				}
 12482  			}
 12483  			intStringLen := int(stringLen)
 12484  			if intStringLen < 0 {
 12485  				return ErrInvalidLength
 12486  			}
 12487  			postIndex := iNdEx + intStringLen
 12488  			if postIndex < 0 {
 12489  				return ErrInvalidLength
 12490  			}
 12491  			if postIndex > l {
 12492  				return io.ErrUnexpectedEOF
 12493  			}
 12494  			m.Position = string(dAtA[iNdEx:postIndex])
 12495  			iNdEx = postIndex
 12496  		default:
 12497  			iNdEx = preIndex
 12498  			skippy, err := skip(dAtA[iNdEx:])
 12499  			if err != nil {
 12500  				return err
 12501  			}
 12502  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12503  				return ErrInvalidLength
 12504  			}
 12505  			if (iNdEx + skippy) > l {
 12506  				return io.ErrUnexpectedEOF
 12507  			}
 12508  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12509  			iNdEx += skippy
 12510  		}
 12511  	}
 12512  
 12513  	if iNdEx > l {
 12514  		return io.ErrUnexpectedEOF
 12515  	}
 12516  	return nil
 12517  }
 12518  func (m *VReplicationWaitForPosResponse) UnmarshalVT(dAtA []byte) error {
 12519  	l := len(dAtA)
 12520  	iNdEx := 0
 12521  	for iNdEx < l {
 12522  		preIndex := iNdEx
 12523  		var wire uint64
 12524  		for shift := uint(0); ; shift += 7 {
 12525  			if shift >= 64 {
 12526  				return ErrIntOverflow
 12527  			}
 12528  			if iNdEx >= l {
 12529  				return io.ErrUnexpectedEOF
 12530  			}
 12531  			b := dAtA[iNdEx]
 12532  			iNdEx++
 12533  			wire |= uint64(b&0x7F) << shift
 12534  			if b < 0x80 {
 12535  				break
 12536  			}
 12537  		}
 12538  		fieldNum := int32(wire >> 3)
 12539  		wireType := int(wire & 0x7)
 12540  		if wireType == 4 {
 12541  			return fmt.Errorf("proto: VReplicationWaitForPosResponse: wiretype end group for non-group")
 12542  		}
 12543  		if fieldNum <= 0 {
 12544  			return fmt.Errorf("proto: VReplicationWaitForPosResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12545  		}
 12546  		switch fieldNum {
 12547  		default:
 12548  			iNdEx = preIndex
 12549  			skippy, err := skip(dAtA[iNdEx:])
 12550  			if err != nil {
 12551  				return err
 12552  			}
 12553  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12554  				return ErrInvalidLength
 12555  			}
 12556  			if (iNdEx + skippy) > l {
 12557  				return io.ErrUnexpectedEOF
 12558  			}
 12559  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12560  			iNdEx += skippy
 12561  		}
 12562  	}
 12563  
 12564  	if iNdEx > l {
 12565  		return io.ErrUnexpectedEOF
 12566  	}
 12567  	return nil
 12568  }
 12569  func (m *InitPrimaryRequest) UnmarshalVT(dAtA []byte) error {
 12570  	l := len(dAtA)
 12571  	iNdEx := 0
 12572  	for iNdEx < l {
 12573  		preIndex := iNdEx
 12574  		var wire uint64
 12575  		for shift := uint(0); ; shift += 7 {
 12576  			if shift >= 64 {
 12577  				return ErrIntOverflow
 12578  			}
 12579  			if iNdEx >= l {
 12580  				return io.ErrUnexpectedEOF
 12581  			}
 12582  			b := dAtA[iNdEx]
 12583  			iNdEx++
 12584  			wire |= uint64(b&0x7F) << shift
 12585  			if b < 0x80 {
 12586  				break
 12587  			}
 12588  		}
 12589  		fieldNum := int32(wire >> 3)
 12590  		wireType := int(wire & 0x7)
 12591  		if wireType == 4 {
 12592  			return fmt.Errorf("proto: InitPrimaryRequest: wiretype end group for non-group")
 12593  		}
 12594  		if fieldNum <= 0 {
 12595  			return fmt.Errorf("proto: InitPrimaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12596  		}
 12597  		switch fieldNum {
 12598  		case 1:
 12599  			if wireType != 0 {
 12600  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
 12601  			}
 12602  			var v int
 12603  			for shift := uint(0); ; shift += 7 {
 12604  				if shift >= 64 {
 12605  					return ErrIntOverflow
 12606  				}
 12607  				if iNdEx >= l {
 12608  					return io.ErrUnexpectedEOF
 12609  				}
 12610  				b := dAtA[iNdEx]
 12611  				iNdEx++
 12612  				v |= int(b&0x7F) << shift
 12613  				if b < 0x80 {
 12614  					break
 12615  				}
 12616  			}
 12617  			m.SemiSync = bool(v != 0)
 12618  		default:
 12619  			iNdEx = preIndex
 12620  			skippy, err := skip(dAtA[iNdEx:])
 12621  			if err != nil {
 12622  				return err
 12623  			}
 12624  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12625  				return ErrInvalidLength
 12626  			}
 12627  			if (iNdEx + skippy) > l {
 12628  				return io.ErrUnexpectedEOF
 12629  			}
 12630  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12631  			iNdEx += skippy
 12632  		}
 12633  	}
 12634  
 12635  	if iNdEx > l {
 12636  		return io.ErrUnexpectedEOF
 12637  	}
 12638  	return nil
 12639  }
 12640  func (m *InitPrimaryResponse) UnmarshalVT(dAtA []byte) error {
 12641  	l := len(dAtA)
 12642  	iNdEx := 0
 12643  	for iNdEx < l {
 12644  		preIndex := iNdEx
 12645  		var wire uint64
 12646  		for shift := uint(0); ; shift += 7 {
 12647  			if shift >= 64 {
 12648  				return ErrIntOverflow
 12649  			}
 12650  			if iNdEx >= l {
 12651  				return io.ErrUnexpectedEOF
 12652  			}
 12653  			b := dAtA[iNdEx]
 12654  			iNdEx++
 12655  			wire |= uint64(b&0x7F) << shift
 12656  			if b < 0x80 {
 12657  				break
 12658  			}
 12659  		}
 12660  		fieldNum := int32(wire >> 3)
 12661  		wireType := int(wire & 0x7)
 12662  		if wireType == 4 {
 12663  			return fmt.Errorf("proto: InitPrimaryResponse: wiretype end group for non-group")
 12664  		}
 12665  		if fieldNum <= 0 {
 12666  			return fmt.Errorf("proto: InitPrimaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12667  		}
 12668  		switch fieldNum {
 12669  		case 1:
 12670  			if wireType != 2 {
 12671  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 12672  			}
 12673  			var stringLen uint64
 12674  			for shift := uint(0); ; shift += 7 {
 12675  				if shift >= 64 {
 12676  					return ErrIntOverflow
 12677  				}
 12678  				if iNdEx >= l {
 12679  					return io.ErrUnexpectedEOF
 12680  				}
 12681  				b := dAtA[iNdEx]
 12682  				iNdEx++
 12683  				stringLen |= uint64(b&0x7F) << shift
 12684  				if b < 0x80 {
 12685  					break
 12686  				}
 12687  			}
 12688  			intStringLen := int(stringLen)
 12689  			if intStringLen < 0 {
 12690  				return ErrInvalidLength
 12691  			}
 12692  			postIndex := iNdEx + intStringLen
 12693  			if postIndex < 0 {
 12694  				return ErrInvalidLength
 12695  			}
 12696  			if postIndex > l {
 12697  				return io.ErrUnexpectedEOF
 12698  			}
 12699  			m.Position = string(dAtA[iNdEx:postIndex])
 12700  			iNdEx = postIndex
 12701  		default:
 12702  			iNdEx = preIndex
 12703  			skippy, err := skip(dAtA[iNdEx:])
 12704  			if err != nil {
 12705  				return err
 12706  			}
 12707  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12708  				return ErrInvalidLength
 12709  			}
 12710  			if (iNdEx + skippy) > l {
 12711  				return io.ErrUnexpectedEOF
 12712  			}
 12713  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12714  			iNdEx += skippy
 12715  		}
 12716  	}
 12717  
 12718  	if iNdEx > l {
 12719  		return io.ErrUnexpectedEOF
 12720  	}
 12721  	return nil
 12722  }
 12723  func (m *PopulateReparentJournalRequest) UnmarshalVT(dAtA []byte) error {
 12724  	l := len(dAtA)
 12725  	iNdEx := 0
 12726  	for iNdEx < l {
 12727  		preIndex := iNdEx
 12728  		var wire uint64
 12729  		for shift := uint(0); ; shift += 7 {
 12730  			if shift >= 64 {
 12731  				return ErrIntOverflow
 12732  			}
 12733  			if iNdEx >= l {
 12734  				return io.ErrUnexpectedEOF
 12735  			}
 12736  			b := dAtA[iNdEx]
 12737  			iNdEx++
 12738  			wire |= uint64(b&0x7F) << shift
 12739  			if b < 0x80 {
 12740  				break
 12741  			}
 12742  		}
 12743  		fieldNum := int32(wire >> 3)
 12744  		wireType := int(wire & 0x7)
 12745  		if wireType == 4 {
 12746  			return fmt.Errorf("proto: PopulateReparentJournalRequest: wiretype end group for non-group")
 12747  		}
 12748  		if fieldNum <= 0 {
 12749  			return fmt.Errorf("proto: PopulateReparentJournalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12750  		}
 12751  		switch fieldNum {
 12752  		case 1:
 12753  			if wireType != 0 {
 12754  				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreatedNs", wireType)
 12755  			}
 12756  			m.TimeCreatedNs = 0
 12757  			for shift := uint(0); ; shift += 7 {
 12758  				if shift >= 64 {
 12759  					return ErrIntOverflow
 12760  				}
 12761  				if iNdEx >= l {
 12762  					return io.ErrUnexpectedEOF
 12763  				}
 12764  				b := dAtA[iNdEx]
 12765  				iNdEx++
 12766  				m.TimeCreatedNs |= int64(b&0x7F) << shift
 12767  				if b < 0x80 {
 12768  					break
 12769  				}
 12770  			}
 12771  		case 2:
 12772  			if wireType != 2 {
 12773  				return fmt.Errorf("proto: wrong wireType = %d for field ActionName", wireType)
 12774  			}
 12775  			var stringLen uint64
 12776  			for shift := uint(0); ; shift += 7 {
 12777  				if shift >= 64 {
 12778  					return ErrIntOverflow
 12779  				}
 12780  				if iNdEx >= l {
 12781  					return io.ErrUnexpectedEOF
 12782  				}
 12783  				b := dAtA[iNdEx]
 12784  				iNdEx++
 12785  				stringLen |= uint64(b&0x7F) << shift
 12786  				if b < 0x80 {
 12787  					break
 12788  				}
 12789  			}
 12790  			intStringLen := int(stringLen)
 12791  			if intStringLen < 0 {
 12792  				return ErrInvalidLength
 12793  			}
 12794  			postIndex := iNdEx + intStringLen
 12795  			if postIndex < 0 {
 12796  				return ErrInvalidLength
 12797  			}
 12798  			if postIndex > l {
 12799  				return io.ErrUnexpectedEOF
 12800  			}
 12801  			m.ActionName = string(dAtA[iNdEx:postIndex])
 12802  			iNdEx = postIndex
 12803  		case 3:
 12804  			if wireType != 2 {
 12805  				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryAlias", wireType)
 12806  			}
 12807  			var msglen int
 12808  			for shift := uint(0); ; shift += 7 {
 12809  				if shift >= 64 {
 12810  					return ErrIntOverflow
 12811  				}
 12812  				if iNdEx >= l {
 12813  					return io.ErrUnexpectedEOF
 12814  				}
 12815  				b := dAtA[iNdEx]
 12816  				iNdEx++
 12817  				msglen |= int(b&0x7F) << shift
 12818  				if b < 0x80 {
 12819  					break
 12820  				}
 12821  			}
 12822  			if msglen < 0 {
 12823  				return ErrInvalidLength
 12824  			}
 12825  			postIndex := iNdEx + msglen
 12826  			if postIndex < 0 {
 12827  				return ErrInvalidLength
 12828  			}
 12829  			if postIndex > l {
 12830  				return io.ErrUnexpectedEOF
 12831  			}
 12832  			if m.PrimaryAlias == nil {
 12833  				m.PrimaryAlias = &topodata.TabletAlias{}
 12834  			}
 12835  			if err := m.PrimaryAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 12836  				return err
 12837  			}
 12838  			iNdEx = postIndex
 12839  		case 4:
 12840  			if wireType != 2 {
 12841  				return fmt.Errorf("proto: wrong wireType = %d for field ReplicationPosition", wireType)
 12842  			}
 12843  			var stringLen uint64
 12844  			for shift := uint(0); ; shift += 7 {
 12845  				if shift >= 64 {
 12846  					return ErrIntOverflow
 12847  				}
 12848  				if iNdEx >= l {
 12849  					return io.ErrUnexpectedEOF
 12850  				}
 12851  				b := dAtA[iNdEx]
 12852  				iNdEx++
 12853  				stringLen |= uint64(b&0x7F) << shift
 12854  				if b < 0x80 {
 12855  					break
 12856  				}
 12857  			}
 12858  			intStringLen := int(stringLen)
 12859  			if intStringLen < 0 {
 12860  				return ErrInvalidLength
 12861  			}
 12862  			postIndex := iNdEx + intStringLen
 12863  			if postIndex < 0 {
 12864  				return ErrInvalidLength
 12865  			}
 12866  			if postIndex > l {
 12867  				return io.ErrUnexpectedEOF
 12868  			}
 12869  			m.ReplicationPosition = string(dAtA[iNdEx:postIndex])
 12870  			iNdEx = postIndex
 12871  		default:
 12872  			iNdEx = preIndex
 12873  			skippy, err := skip(dAtA[iNdEx:])
 12874  			if err != nil {
 12875  				return err
 12876  			}
 12877  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12878  				return ErrInvalidLength
 12879  			}
 12880  			if (iNdEx + skippy) > l {
 12881  				return io.ErrUnexpectedEOF
 12882  			}
 12883  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12884  			iNdEx += skippy
 12885  		}
 12886  	}
 12887  
 12888  	if iNdEx > l {
 12889  		return io.ErrUnexpectedEOF
 12890  	}
 12891  	return nil
 12892  }
 12893  func (m *PopulateReparentJournalResponse) UnmarshalVT(dAtA []byte) error {
 12894  	l := len(dAtA)
 12895  	iNdEx := 0
 12896  	for iNdEx < l {
 12897  		preIndex := iNdEx
 12898  		var wire uint64
 12899  		for shift := uint(0); ; shift += 7 {
 12900  			if shift >= 64 {
 12901  				return ErrIntOverflow
 12902  			}
 12903  			if iNdEx >= l {
 12904  				return io.ErrUnexpectedEOF
 12905  			}
 12906  			b := dAtA[iNdEx]
 12907  			iNdEx++
 12908  			wire |= uint64(b&0x7F) << shift
 12909  			if b < 0x80 {
 12910  				break
 12911  			}
 12912  		}
 12913  		fieldNum := int32(wire >> 3)
 12914  		wireType := int(wire & 0x7)
 12915  		if wireType == 4 {
 12916  			return fmt.Errorf("proto: PopulateReparentJournalResponse: wiretype end group for non-group")
 12917  		}
 12918  		if fieldNum <= 0 {
 12919  			return fmt.Errorf("proto: PopulateReparentJournalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 12920  		}
 12921  		switch fieldNum {
 12922  		default:
 12923  			iNdEx = preIndex
 12924  			skippy, err := skip(dAtA[iNdEx:])
 12925  			if err != nil {
 12926  				return err
 12927  			}
 12928  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 12929  				return ErrInvalidLength
 12930  			}
 12931  			if (iNdEx + skippy) > l {
 12932  				return io.ErrUnexpectedEOF
 12933  			}
 12934  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 12935  			iNdEx += skippy
 12936  		}
 12937  	}
 12938  
 12939  	if iNdEx > l {
 12940  		return io.ErrUnexpectedEOF
 12941  	}
 12942  	return nil
 12943  }
 12944  func (m *InitReplicaRequest) UnmarshalVT(dAtA []byte) error {
 12945  	l := len(dAtA)
 12946  	iNdEx := 0
 12947  	for iNdEx < l {
 12948  		preIndex := iNdEx
 12949  		var wire uint64
 12950  		for shift := uint(0); ; shift += 7 {
 12951  			if shift >= 64 {
 12952  				return ErrIntOverflow
 12953  			}
 12954  			if iNdEx >= l {
 12955  				return io.ErrUnexpectedEOF
 12956  			}
 12957  			b := dAtA[iNdEx]
 12958  			iNdEx++
 12959  			wire |= uint64(b&0x7F) << shift
 12960  			if b < 0x80 {
 12961  				break
 12962  			}
 12963  		}
 12964  		fieldNum := int32(wire >> 3)
 12965  		wireType := int(wire & 0x7)
 12966  		if wireType == 4 {
 12967  			return fmt.Errorf("proto: InitReplicaRequest: wiretype end group for non-group")
 12968  		}
 12969  		if fieldNum <= 0 {
 12970  			return fmt.Errorf("proto: InitReplicaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 12971  		}
 12972  		switch fieldNum {
 12973  		case 1:
 12974  			if wireType != 2 {
 12975  				return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType)
 12976  			}
 12977  			var msglen int
 12978  			for shift := uint(0); ; shift += 7 {
 12979  				if shift >= 64 {
 12980  					return ErrIntOverflow
 12981  				}
 12982  				if iNdEx >= l {
 12983  					return io.ErrUnexpectedEOF
 12984  				}
 12985  				b := dAtA[iNdEx]
 12986  				iNdEx++
 12987  				msglen |= int(b&0x7F) << shift
 12988  				if b < 0x80 {
 12989  					break
 12990  				}
 12991  			}
 12992  			if msglen < 0 {
 12993  				return ErrInvalidLength
 12994  			}
 12995  			postIndex := iNdEx + msglen
 12996  			if postIndex < 0 {
 12997  				return ErrInvalidLength
 12998  			}
 12999  			if postIndex > l {
 13000  				return io.ErrUnexpectedEOF
 13001  			}
 13002  			if m.Parent == nil {
 13003  				m.Parent = &topodata.TabletAlias{}
 13004  			}
 13005  			if err := m.Parent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13006  				return err
 13007  			}
 13008  			iNdEx = postIndex
 13009  		case 2:
 13010  			if wireType != 2 {
 13011  				return fmt.Errorf("proto: wrong wireType = %d for field ReplicationPosition", wireType)
 13012  			}
 13013  			var stringLen uint64
 13014  			for shift := uint(0); ; shift += 7 {
 13015  				if shift >= 64 {
 13016  					return ErrIntOverflow
 13017  				}
 13018  				if iNdEx >= l {
 13019  					return io.ErrUnexpectedEOF
 13020  				}
 13021  				b := dAtA[iNdEx]
 13022  				iNdEx++
 13023  				stringLen |= uint64(b&0x7F) << shift
 13024  				if b < 0x80 {
 13025  					break
 13026  				}
 13027  			}
 13028  			intStringLen := int(stringLen)
 13029  			if intStringLen < 0 {
 13030  				return ErrInvalidLength
 13031  			}
 13032  			postIndex := iNdEx + intStringLen
 13033  			if postIndex < 0 {
 13034  				return ErrInvalidLength
 13035  			}
 13036  			if postIndex > l {
 13037  				return io.ErrUnexpectedEOF
 13038  			}
 13039  			m.ReplicationPosition = string(dAtA[iNdEx:postIndex])
 13040  			iNdEx = postIndex
 13041  		case 3:
 13042  			if wireType != 0 {
 13043  				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreatedNs", wireType)
 13044  			}
 13045  			m.TimeCreatedNs = 0
 13046  			for shift := uint(0); ; shift += 7 {
 13047  				if shift >= 64 {
 13048  					return ErrIntOverflow
 13049  				}
 13050  				if iNdEx >= l {
 13051  					return io.ErrUnexpectedEOF
 13052  				}
 13053  				b := dAtA[iNdEx]
 13054  				iNdEx++
 13055  				m.TimeCreatedNs |= int64(b&0x7F) << shift
 13056  				if b < 0x80 {
 13057  					break
 13058  				}
 13059  			}
 13060  		case 4:
 13061  			if wireType != 0 {
 13062  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
 13063  			}
 13064  			var v int
 13065  			for shift := uint(0); ; shift += 7 {
 13066  				if shift >= 64 {
 13067  					return ErrIntOverflow
 13068  				}
 13069  				if iNdEx >= l {
 13070  					return io.ErrUnexpectedEOF
 13071  				}
 13072  				b := dAtA[iNdEx]
 13073  				iNdEx++
 13074  				v |= int(b&0x7F) << shift
 13075  				if b < 0x80 {
 13076  					break
 13077  				}
 13078  			}
 13079  			m.SemiSync = bool(v != 0)
 13080  		default:
 13081  			iNdEx = preIndex
 13082  			skippy, err := skip(dAtA[iNdEx:])
 13083  			if err != nil {
 13084  				return err
 13085  			}
 13086  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13087  				return ErrInvalidLength
 13088  			}
 13089  			if (iNdEx + skippy) > l {
 13090  				return io.ErrUnexpectedEOF
 13091  			}
 13092  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13093  			iNdEx += skippy
 13094  		}
 13095  	}
 13096  
 13097  	if iNdEx > l {
 13098  		return io.ErrUnexpectedEOF
 13099  	}
 13100  	return nil
 13101  }
 13102  func (m *InitReplicaResponse) UnmarshalVT(dAtA []byte) error {
 13103  	l := len(dAtA)
 13104  	iNdEx := 0
 13105  	for iNdEx < l {
 13106  		preIndex := iNdEx
 13107  		var wire uint64
 13108  		for shift := uint(0); ; shift += 7 {
 13109  			if shift >= 64 {
 13110  				return ErrIntOverflow
 13111  			}
 13112  			if iNdEx >= l {
 13113  				return io.ErrUnexpectedEOF
 13114  			}
 13115  			b := dAtA[iNdEx]
 13116  			iNdEx++
 13117  			wire |= uint64(b&0x7F) << shift
 13118  			if b < 0x80 {
 13119  				break
 13120  			}
 13121  		}
 13122  		fieldNum := int32(wire >> 3)
 13123  		wireType := int(wire & 0x7)
 13124  		if wireType == 4 {
 13125  			return fmt.Errorf("proto: InitReplicaResponse: wiretype end group for non-group")
 13126  		}
 13127  		if fieldNum <= 0 {
 13128  			return fmt.Errorf("proto: InitReplicaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13129  		}
 13130  		switch fieldNum {
 13131  		default:
 13132  			iNdEx = preIndex
 13133  			skippy, err := skip(dAtA[iNdEx:])
 13134  			if err != nil {
 13135  				return err
 13136  			}
 13137  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13138  				return ErrInvalidLength
 13139  			}
 13140  			if (iNdEx + skippy) > l {
 13141  				return io.ErrUnexpectedEOF
 13142  			}
 13143  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13144  			iNdEx += skippy
 13145  		}
 13146  	}
 13147  
 13148  	if iNdEx > l {
 13149  		return io.ErrUnexpectedEOF
 13150  	}
 13151  	return nil
 13152  }
 13153  func (m *DemotePrimaryRequest) UnmarshalVT(dAtA []byte) error {
 13154  	l := len(dAtA)
 13155  	iNdEx := 0
 13156  	for iNdEx < l {
 13157  		preIndex := iNdEx
 13158  		var wire uint64
 13159  		for shift := uint(0); ; shift += 7 {
 13160  			if shift >= 64 {
 13161  				return ErrIntOverflow
 13162  			}
 13163  			if iNdEx >= l {
 13164  				return io.ErrUnexpectedEOF
 13165  			}
 13166  			b := dAtA[iNdEx]
 13167  			iNdEx++
 13168  			wire |= uint64(b&0x7F) << shift
 13169  			if b < 0x80 {
 13170  				break
 13171  			}
 13172  		}
 13173  		fieldNum := int32(wire >> 3)
 13174  		wireType := int(wire & 0x7)
 13175  		if wireType == 4 {
 13176  			return fmt.Errorf("proto: DemotePrimaryRequest: wiretype end group for non-group")
 13177  		}
 13178  		if fieldNum <= 0 {
 13179  			return fmt.Errorf("proto: DemotePrimaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13180  		}
 13181  		switch fieldNum {
 13182  		default:
 13183  			iNdEx = preIndex
 13184  			skippy, err := skip(dAtA[iNdEx:])
 13185  			if err != nil {
 13186  				return err
 13187  			}
 13188  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13189  				return ErrInvalidLength
 13190  			}
 13191  			if (iNdEx + skippy) > l {
 13192  				return io.ErrUnexpectedEOF
 13193  			}
 13194  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13195  			iNdEx += skippy
 13196  		}
 13197  	}
 13198  
 13199  	if iNdEx > l {
 13200  		return io.ErrUnexpectedEOF
 13201  	}
 13202  	return nil
 13203  }
 13204  func (m *DemotePrimaryResponse) UnmarshalVT(dAtA []byte) error {
 13205  	l := len(dAtA)
 13206  	iNdEx := 0
 13207  	for iNdEx < l {
 13208  		preIndex := iNdEx
 13209  		var wire uint64
 13210  		for shift := uint(0); ; shift += 7 {
 13211  			if shift >= 64 {
 13212  				return ErrIntOverflow
 13213  			}
 13214  			if iNdEx >= l {
 13215  				return io.ErrUnexpectedEOF
 13216  			}
 13217  			b := dAtA[iNdEx]
 13218  			iNdEx++
 13219  			wire |= uint64(b&0x7F) << shift
 13220  			if b < 0x80 {
 13221  				break
 13222  			}
 13223  		}
 13224  		fieldNum := int32(wire >> 3)
 13225  		wireType := int(wire & 0x7)
 13226  		if wireType == 4 {
 13227  			return fmt.Errorf("proto: DemotePrimaryResponse: wiretype end group for non-group")
 13228  		}
 13229  		if fieldNum <= 0 {
 13230  			return fmt.Errorf("proto: DemotePrimaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13231  		}
 13232  		switch fieldNum {
 13233  		case 2:
 13234  			if wireType != 2 {
 13235  				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryStatus", wireType)
 13236  			}
 13237  			var msglen int
 13238  			for shift := uint(0); ; shift += 7 {
 13239  				if shift >= 64 {
 13240  					return ErrIntOverflow
 13241  				}
 13242  				if iNdEx >= l {
 13243  					return io.ErrUnexpectedEOF
 13244  				}
 13245  				b := dAtA[iNdEx]
 13246  				iNdEx++
 13247  				msglen |= int(b&0x7F) << shift
 13248  				if b < 0x80 {
 13249  					break
 13250  				}
 13251  			}
 13252  			if msglen < 0 {
 13253  				return ErrInvalidLength
 13254  			}
 13255  			postIndex := iNdEx + msglen
 13256  			if postIndex < 0 {
 13257  				return ErrInvalidLength
 13258  			}
 13259  			if postIndex > l {
 13260  				return io.ErrUnexpectedEOF
 13261  			}
 13262  			if m.PrimaryStatus == nil {
 13263  				m.PrimaryStatus = &replicationdata.PrimaryStatus{}
 13264  			}
 13265  			if err := m.PrimaryStatus.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13266  				return err
 13267  			}
 13268  			iNdEx = postIndex
 13269  		default:
 13270  			iNdEx = preIndex
 13271  			skippy, err := skip(dAtA[iNdEx:])
 13272  			if err != nil {
 13273  				return err
 13274  			}
 13275  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13276  				return ErrInvalidLength
 13277  			}
 13278  			if (iNdEx + skippy) > l {
 13279  				return io.ErrUnexpectedEOF
 13280  			}
 13281  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13282  			iNdEx += skippy
 13283  		}
 13284  	}
 13285  
 13286  	if iNdEx > l {
 13287  		return io.ErrUnexpectedEOF
 13288  	}
 13289  	return nil
 13290  }
 13291  func (m *UndoDemotePrimaryRequest) UnmarshalVT(dAtA []byte) error {
 13292  	l := len(dAtA)
 13293  	iNdEx := 0
 13294  	for iNdEx < l {
 13295  		preIndex := iNdEx
 13296  		var wire uint64
 13297  		for shift := uint(0); ; shift += 7 {
 13298  			if shift >= 64 {
 13299  				return ErrIntOverflow
 13300  			}
 13301  			if iNdEx >= l {
 13302  				return io.ErrUnexpectedEOF
 13303  			}
 13304  			b := dAtA[iNdEx]
 13305  			iNdEx++
 13306  			wire |= uint64(b&0x7F) << shift
 13307  			if b < 0x80 {
 13308  				break
 13309  			}
 13310  		}
 13311  		fieldNum := int32(wire >> 3)
 13312  		wireType := int(wire & 0x7)
 13313  		if wireType == 4 {
 13314  			return fmt.Errorf("proto: UndoDemotePrimaryRequest: wiretype end group for non-group")
 13315  		}
 13316  		if fieldNum <= 0 {
 13317  			return fmt.Errorf("proto: UndoDemotePrimaryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13318  		}
 13319  		switch fieldNum {
 13320  		case 1:
 13321  			if wireType != 0 {
 13322  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
 13323  			}
 13324  			var v int
 13325  			for shift := uint(0); ; shift += 7 {
 13326  				if shift >= 64 {
 13327  					return ErrIntOverflow
 13328  				}
 13329  				if iNdEx >= l {
 13330  					return io.ErrUnexpectedEOF
 13331  				}
 13332  				b := dAtA[iNdEx]
 13333  				iNdEx++
 13334  				v |= int(b&0x7F) << shift
 13335  				if b < 0x80 {
 13336  					break
 13337  				}
 13338  			}
 13339  			m.SemiSync = bool(v != 0)
 13340  		default:
 13341  			iNdEx = preIndex
 13342  			skippy, err := skip(dAtA[iNdEx:])
 13343  			if err != nil {
 13344  				return err
 13345  			}
 13346  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13347  				return ErrInvalidLength
 13348  			}
 13349  			if (iNdEx + skippy) > l {
 13350  				return io.ErrUnexpectedEOF
 13351  			}
 13352  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13353  			iNdEx += skippy
 13354  		}
 13355  	}
 13356  
 13357  	if iNdEx > l {
 13358  		return io.ErrUnexpectedEOF
 13359  	}
 13360  	return nil
 13361  }
 13362  func (m *UndoDemotePrimaryResponse) UnmarshalVT(dAtA []byte) error {
 13363  	l := len(dAtA)
 13364  	iNdEx := 0
 13365  	for iNdEx < l {
 13366  		preIndex := iNdEx
 13367  		var wire uint64
 13368  		for shift := uint(0); ; shift += 7 {
 13369  			if shift >= 64 {
 13370  				return ErrIntOverflow
 13371  			}
 13372  			if iNdEx >= l {
 13373  				return io.ErrUnexpectedEOF
 13374  			}
 13375  			b := dAtA[iNdEx]
 13376  			iNdEx++
 13377  			wire |= uint64(b&0x7F) << shift
 13378  			if b < 0x80 {
 13379  				break
 13380  			}
 13381  		}
 13382  		fieldNum := int32(wire >> 3)
 13383  		wireType := int(wire & 0x7)
 13384  		if wireType == 4 {
 13385  			return fmt.Errorf("proto: UndoDemotePrimaryResponse: wiretype end group for non-group")
 13386  		}
 13387  		if fieldNum <= 0 {
 13388  			return fmt.Errorf("proto: UndoDemotePrimaryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13389  		}
 13390  		switch fieldNum {
 13391  		default:
 13392  			iNdEx = preIndex
 13393  			skippy, err := skip(dAtA[iNdEx:])
 13394  			if err != nil {
 13395  				return err
 13396  			}
 13397  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13398  				return ErrInvalidLength
 13399  			}
 13400  			if (iNdEx + skippy) > l {
 13401  				return io.ErrUnexpectedEOF
 13402  			}
 13403  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13404  			iNdEx += skippy
 13405  		}
 13406  	}
 13407  
 13408  	if iNdEx > l {
 13409  		return io.ErrUnexpectedEOF
 13410  	}
 13411  	return nil
 13412  }
 13413  func (m *ReplicaWasPromotedRequest) UnmarshalVT(dAtA []byte) error {
 13414  	l := len(dAtA)
 13415  	iNdEx := 0
 13416  	for iNdEx < l {
 13417  		preIndex := iNdEx
 13418  		var wire uint64
 13419  		for shift := uint(0); ; shift += 7 {
 13420  			if shift >= 64 {
 13421  				return ErrIntOverflow
 13422  			}
 13423  			if iNdEx >= l {
 13424  				return io.ErrUnexpectedEOF
 13425  			}
 13426  			b := dAtA[iNdEx]
 13427  			iNdEx++
 13428  			wire |= uint64(b&0x7F) << shift
 13429  			if b < 0x80 {
 13430  				break
 13431  			}
 13432  		}
 13433  		fieldNum := int32(wire >> 3)
 13434  		wireType := int(wire & 0x7)
 13435  		if wireType == 4 {
 13436  			return fmt.Errorf("proto: ReplicaWasPromotedRequest: wiretype end group for non-group")
 13437  		}
 13438  		if fieldNum <= 0 {
 13439  			return fmt.Errorf("proto: ReplicaWasPromotedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13440  		}
 13441  		switch fieldNum {
 13442  		default:
 13443  			iNdEx = preIndex
 13444  			skippy, err := skip(dAtA[iNdEx:])
 13445  			if err != nil {
 13446  				return err
 13447  			}
 13448  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13449  				return ErrInvalidLength
 13450  			}
 13451  			if (iNdEx + skippy) > l {
 13452  				return io.ErrUnexpectedEOF
 13453  			}
 13454  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13455  			iNdEx += skippy
 13456  		}
 13457  	}
 13458  
 13459  	if iNdEx > l {
 13460  		return io.ErrUnexpectedEOF
 13461  	}
 13462  	return nil
 13463  }
 13464  func (m *ReplicaWasPromotedResponse) UnmarshalVT(dAtA []byte) error {
 13465  	l := len(dAtA)
 13466  	iNdEx := 0
 13467  	for iNdEx < l {
 13468  		preIndex := iNdEx
 13469  		var wire uint64
 13470  		for shift := uint(0); ; shift += 7 {
 13471  			if shift >= 64 {
 13472  				return ErrIntOverflow
 13473  			}
 13474  			if iNdEx >= l {
 13475  				return io.ErrUnexpectedEOF
 13476  			}
 13477  			b := dAtA[iNdEx]
 13478  			iNdEx++
 13479  			wire |= uint64(b&0x7F) << shift
 13480  			if b < 0x80 {
 13481  				break
 13482  			}
 13483  		}
 13484  		fieldNum := int32(wire >> 3)
 13485  		wireType := int(wire & 0x7)
 13486  		if wireType == 4 {
 13487  			return fmt.Errorf("proto: ReplicaWasPromotedResponse: wiretype end group for non-group")
 13488  		}
 13489  		if fieldNum <= 0 {
 13490  			return fmt.Errorf("proto: ReplicaWasPromotedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13491  		}
 13492  		switch fieldNum {
 13493  		default:
 13494  			iNdEx = preIndex
 13495  			skippy, err := skip(dAtA[iNdEx:])
 13496  			if err != nil {
 13497  				return err
 13498  			}
 13499  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13500  				return ErrInvalidLength
 13501  			}
 13502  			if (iNdEx + skippy) > l {
 13503  				return io.ErrUnexpectedEOF
 13504  			}
 13505  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13506  			iNdEx += skippy
 13507  		}
 13508  	}
 13509  
 13510  	if iNdEx > l {
 13511  		return io.ErrUnexpectedEOF
 13512  	}
 13513  	return nil
 13514  }
 13515  func (m *ResetReplicationParametersRequest) UnmarshalVT(dAtA []byte) error {
 13516  	l := len(dAtA)
 13517  	iNdEx := 0
 13518  	for iNdEx < l {
 13519  		preIndex := iNdEx
 13520  		var wire uint64
 13521  		for shift := uint(0); ; shift += 7 {
 13522  			if shift >= 64 {
 13523  				return ErrIntOverflow
 13524  			}
 13525  			if iNdEx >= l {
 13526  				return io.ErrUnexpectedEOF
 13527  			}
 13528  			b := dAtA[iNdEx]
 13529  			iNdEx++
 13530  			wire |= uint64(b&0x7F) << shift
 13531  			if b < 0x80 {
 13532  				break
 13533  			}
 13534  		}
 13535  		fieldNum := int32(wire >> 3)
 13536  		wireType := int(wire & 0x7)
 13537  		if wireType == 4 {
 13538  			return fmt.Errorf("proto: ResetReplicationParametersRequest: wiretype end group for non-group")
 13539  		}
 13540  		if fieldNum <= 0 {
 13541  			return fmt.Errorf("proto: ResetReplicationParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13542  		}
 13543  		switch fieldNum {
 13544  		default:
 13545  			iNdEx = preIndex
 13546  			skippy, err := skip(dAtA[iNdEx:])
 13547  			if err != nil {
 13548  				return err
 13549  			}
 13550  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13551  				return ErrInvalidLength
 13552  			}
 13553  			if (iNdEx + skippy) > l {
 13554  				return io.ErrUnexpectedEOF
 13555  			}
 13556  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13557  			iNdEx += skippy
 13558  		}
 13559  	}
 13560  
 13561  	if iNdEx > l {
 13562  		return io.ErrUnexpectedEOF
 13563  	}
 13564  	return nil
 13565  }
 13566  func (m *ResetReplicationParametersResponse) UnmarshalVT(dAtA []byte) error {
 13567  	l := len(dAtA)
 13568  	iNdEx := 0
 13569  	for iNdEx < l {
 13570  		preIndex := iNdEx
 13571  		var wire uint64
 13572  		for shift := uint(0); ; shift += 7 {
 13573  			if shift >= 64 {
 13574  				return ErrIntOverflow
 13575  			}
 13576  			if iNdEx >= l {
 13577  				return io.ErrUnexpectedEOF
 13578  			}
 13579  			b := dAtA[iNdEx]
 13580  			iNdEx++
 13581  			wire |= uint64(b&0x7F) << shift
 13582  			if b < 0x80 {
 13583  				break
 13584  			}
 13585  		}
 13586  		fieldNum := int32(wire >> 3)
 13587  		wireType := int(wire & 0x7)
 13588  		if wireType == 4 {
 13589  			return fmt.Errorf("proto: ResetReplicationParametersResponse: wiretype end group for non-group")
 13590  		}
 13591  		if fieldNum <= 0 {
 13592  			return fmt.Errorf("proto: ResetReplicationParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13593  		}
 13594  		switch fieldNum {
 13595  		default:
 13596  			iNdEx = preIndex
 13597  			skippy, err := skip(dAtA[iNdEx:])
 13598  			if err != nil {
 13599  				return err
 13600  			}
 13601  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13602  				return ErrInvalidLength
 13603  			}
 13604  			if (iNdEx + skippy) > l {
 13605  				return io.ErrUnexpectedEOF
 13606  			}
 13607  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13608  			iNdEx += skippy
 13609  		}
 13610  	}
 13611  
 13612  	if iNdEx > l {
 13613  		return io.ErrUnexpectedEOF
 13614  	}
 13615  	return nil
 13616  }
 13617  func (m *FullStatusRequest) UnmarshalVT(dAtA []byte) error {
 13618  	l := len(dAtA)
 13619  	iNdEx := 0
 13620  	for iNdEx < l {
 13621  		preIndex := iNdEx
 13622  		var wire uint64
 13623  		for shift := uint(0); ; shift += 7 {
 13624  			if shift >= 64 {
 13625  				return ErrIntOverflow
 13626  			}
 13627  			if iNdEx >= l {
 13628  				return io.ErrUnexpectedEOF
 13629  			}
 13630  			b := dAtA[iNdEx]
 13631  			iNdEx++
 13632  			wire |= uint64(b&0x7F) << shift
 13633  			if b < 0x80 {
 13634  				break
 13635  			}
 13636  		}
 13637  		fieldNum := int32(wire >> 3)
 13638  		wireType := int(wire & 0x7)
 13639  		if wireType == 4 {
 13640  			return fmt.Errorf("proto: FullStatusRequest: wiretype end group for non-group")
 13641  		}
 13642  		if fieldNum <= 0 {
 13643  			return fmt.Errorf("proto: FullStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13644  		}
 13645  		switch fieldNum {
 13646  		default:
 13647  			iNdEx = preIndex
 13648  			skippy, err := skip(dAtA[iNdEx:])
 13649  			if err != nil {
 13650  				return err
 13651  			}
 13652  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13653  				return ErrInvalidLength
 13654  			}
 13655  			if (iNdEx + skippy) > l {
 13656  				return io.ErrUnexpectedEOF
 13657  			}
 13658  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13659  			iNdEx += skippy
 13660  		}
 13661  	}
 13662  
 13663  	if iNdEx > l {
 13664  		return io.ErrUnexpectedEOF
 13665  	}
 13666  	return nil
 13667  }
 13668  func (m *FullStatusResponse) UnmarshalVT(dAtA []byte) error {
 13669  	l := len(dAtA)
 13670  	iNdEx := 0
 13671  	for iNdEx < l {
 13672  		preIndex := iNdEx
 13673  		var wire uint64
 13674  		for shift := uint(0); ; shift += 7 {
 13675  			if shift >= 64 {
 13676  				return ErrIntOverflow
 13677  			}
 13678  			if iNdEx >= l {
 13679  				return io.ErrUnexpectedEOF
 13680  			}
 13681  			b := dAtA[iNdEx]
 13682  			iNdEx++
 13683  			wire |= uint64(b&0x7F) << shift
 13684  			if b < 0x80 {
 13685  				break
 13686  			}
 13687  		}
 13688  		fieldNum := int32(wire >> 3)
 13689  		wireType := int(wire & 0x7)
 13690  		if wireType == 4 {
 13691  			return fmt.Errorf("proto: FullStatusResponse: wiretype end group for non-group")
 13692  		}
 13693  		if fieldNum <= 0 {
 13694  			return fmt.Errorf("proto: FullStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13695  		}
 13696  		switch fieldNum {
 13697  		case 1:
 13698  			if wireType != 2 {
 13699  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 13700  			}
 13701  			var msglen int
 13702  			for shift := uint(0); ; shift += 7 {
 13703  				if shift >= 64 {
 13704  					return ErrIntOverflow
 13705  				}
 13706  				if iNdEx >= l {
 13707  					return io.ErrUnexpectedEOF
 13708  				}
 13709  				b := dAtA[iNdEx]
 13710  				iNdEx++
 13711  				msglen |= int(b&0x7F) << shift
 13712  				if b < 0x80 {
 13713  					break
 13714  				}
 13715  			}
 13716  			if msglen < 0 {
 13717  				return ErrInvalidLength
 13718  			}
 13719  			postIndex := iNdEx + msglen
 13720  			if postIndex < 0 {
 13721  				return ErrInvalidLength
 13722  			}
 13723  			if postIndex > l {
 13724  				return io.ErrUnexpectedEOF
 13725  			}
 13726  			if m.Status == nil {
 13727  				m.Status = &replicationdata.FullStatus{}
 13728  			}
 13729  			if err := m.Status.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13730  				return err
 13731  			}
 13732  			iNdEx = postIndex
 13733  		default:
 13734  			iNdEx = preIndex
 13735  			skippy, err := skip(dAtA[iNdEx:])
 13736  			if err != nil {
 13737  				return err
 13738  			}
 13739  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13740  				return ErrInvalidLength
 13741  			}
 13742  			if (iNdEx + skippy) > l {
 13743  				return io.ErrUnexpectedEOF
 13744  			}
 13745  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13746  			iNdEx += skippy
 13747  		}
 13748  	}
 13749  
 13750  	if iNdEx > l {
 13751  		return io.ErrUnexpectedEOF
 13752  	}
 13753  	return nil
 13754  }
 13755  func (m *SetReplicationSourceRequest) UnmarshalVT(dAtA []byte) error {
 13756  	l := len(dAtA)
 13757  	iNdEx := 0
 13758  	for iNdEx < l {
 13759  		preIndex := iNdEx
 13760  		var wire uint64
 13761  		for shift := uint(0); ; shift += 7 {
 13762  			if shift >= 64 {
 13763  				return ErrIntOverflow
 13764  			}
 13765  			if iNdEx >= l {
 13766  				return io.ErrUnexpectedEOF
 13767  			}
 13768  			b := dAtA[iNdEx]
 13769  			iNdEx++
 13770  			wire |= uint64(b&0x7F) << shift
 13771  			if b < 0x80 {
 13772  				break
 13773  			}
 13774  		}
 13775  		fieldNum := int32(wire >> 3)
 13776  		wireType := int(wire & 0x7)
 13777  		if wireType == 4 {
 13778  			return fmt.Errorf("proto: SetReplicationSourceRequest: wiretype end group for non-group")
 13779  		}
 13780  		if fieldNum <= 0 {
 13781  			return fmt.Errorf("proto: SetReplicationSourceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 13782  		}
 13783  		switch fieldNum {
 13784  		case 1:
 13785  			if wireType != 2 {
 13786  				return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType)
 13787  			}
 13788  			var msglen int
 13789  			for shift := uint(0); ; shift += 7 {
 13790  				if shift >= 64 {
 13791  					return ErrIntOverflow
 13792  				}
 13793  				if iNdEx >= l {
 13794  					return io.ErrUnexpectedEOF
 13795  				}
 13796  				b := dAtA[iNdEx]
 13797  				iNdEx++
 13798  				msglen |= int(b&0x7F) << shift
 13799  				if b < 0x80 {
 13800  					break
 13801  				}
 13802  			}
 13803  			if msglen < 0 {
 13804  				return ErrInvalidLength
 13805  			}
 13806  			postIndex := iNdEx + msglen
 13807  			if postIndex < 0 {
 13808  				return ErrInvalidLength
 13809  			}
 13810  			if postIndex > l {
 13811  				return io.ErrUnexpectedEOF
 13812  			}
 13813  			if m.Parent == nil {
 13814  				m.Parent = &topodata.TabletAlias{}
 13815  			}
 13816  			if err := m.Parent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 13817  				return err
 13818  			}
 13819  			iNdEx = postIndex
 13820  		case 2:
 13821  			if wireType != 0 {
 13822  				return fmt.Errorf("proto: wrong wireType = %d for field TimeCreatedNs", wireType)
 13823  			}
 13824  			m.TimeCreatedNs = 0
 13825  			for shift := uint(0); ; shift += 7 {
 13826  				if shift >= 64 {
 13827  					return ErrIntOverflow
 13828  				}
 13829  				if iNdEx >= l {
 13830  					return io.ErrUnexpectedEOF
 13831  				}
 13832  				b := dAtA[iNdEx]
 13833  				iNdEx++
 13834  				m.TimeCreatedNs |= int64(b&0x7F) << shift
 13835  				if b < 0x80 {
 13836  					break
 13837  				}
 13838  			}
 13839  		case 3:
 13840  			if wireType != 0 {
 13841  				return fmt.Errorf("proto: wrong wireType = %d for field ForceStartReplication", wireType)
 13842  			}
 13843  			var v int
 13844  			for shift := uint(0); ; shift += 7 {
 13845  				if shift >= 64 {
 13846  					return ErrIntOverflow
 13847  				}
 13848  				if iNdEx >= l {
 13849  					return io.ErrUnexpectedEOF
 13850  				}
 13851  				b := dAtA[iNdEx]
 13852  				iNdEx++
 13853  				v |= int(b&0x7F) << shift
 13854  				if b < 0x80 {
 13855  					break
 13856  				}
 13857  			}
 13858  			m.ForceStartReplication = bool(v != 0)
 13859  		case 4:
 13860  			if wireType != 2 {
 13861  				return fmt.Errorf("proto: wrong wireType = %d for field WaitPosition", wireType)
 13862  			}
 13863  			var stringLen uint64
 13864  			for shift := uint(0); ; shift += 7 {
 13865  				if shift >= 64 {
 13866  					return ErrIntOverflow
 13867  				}
 13868  				if iNdEx >= l {
 13869  					return io.ErrUnexpectedEOF
 13870  				}
 13871  				b := dAtA[iNdEx]
 13872  				iNdEx++
 13873  				stringLen |= uint64(b&0x7F) << shift
 13874  				if b < 0x80 {
 13875  					break
 13876  				}
 13877  			}
 13878  			intStringLen := int(stringLen)
 13879  			if intStringLen < 0 {
 13880  				return ErrInvalidLength
 13881  			}
 13882  			postIndex := iNdEx + intStringLen
 13883  			if postIndex < 0 {
 13884  				return ErrInvalidLength
 13885  			}
 13886  			if postIndex > l {
 13887  				return io.ErrUnexpectedEOF
 13888  			}
 13889  			m.WaitPosition = string(dAtA[iNdEx:postIndex])
 13890  			iNdEx = postIndex
 13891  		case 5:
 13892  			if wireType != 0 {
 13893  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
 13894  			}
 13895  			var v int
 13896  			for shift := uint(0); ; shift += 7 {
 13897  				if shift >= 64 {
 13898  					return ErrIntOverflow
 13899  				}
 13900  				if iNdEx >= l {
 13901  					return io.ErrUnexpectedEOF
 13902  				}
 13903  				b := dAtA[iNdEx]
 13904  				iNdEx++
 13905  				v |= int(b&0x7F) << shift
 13906  				if b < 0x80 {
 13907  					break
 13908  				}
 13909  			}
 13910  			m.SemiSync = bool(v != 0)
 13911  		default:
 13912  			iNdEx = preIndex
 13913  			skippy, err := skip(dAtA[iNdEx:])
 13914  			if err != nil {
 13915  				return err
 13916  			}
 13917  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13918  				return ErrInvalidLength
 13919  			}
 13920  			if (iNdEx + skippy) > l {
 13921  				return io.ErrUnexpectedEOF
 13922  			}
 13923  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13924  			iNdEx += skippy
 13925  		}
 13926  	}
 13927  
 13928  	if iNdEx > l {
 13929  		return io.ErrUnexpectedEOF
 13930  	}
 13931  	return nil
 13932  }
 13933  func (m *SetReplicationSourceResponse) UnmarshalVT(dAtA []byte) error {
 13934  	l := len(dAtA)
 13935  	iNdEx := 0
 13936  	for iNdEx < l {
 13937  		preIndex := iNdEx
 13938  		var wire uint64
 13939  		for shift := uint(0); ; shift += 7 {
 13940  			if shift >= 64 {
 13941  				return ErrIntOverflow
 13942  			}
 13943  			if iNdEx >= l {
 13944  				return io.ErrUnexpectedEOF
 13945  			}
 13946  			b := dAtA[iNdEx]
 13947  			iNdEx++
 13948  			wire |= uint64(b&0x7F) << shift
 13949  			if b < 0x80 {
 13950  				break
 13951  			}
 13952  		}
 13953  		fieldNum := int32(wire >> 3)
 13954  		wireType := int(wire & 0x7)
 13955  		if wireType == 4 {
 13956  			return fmt.Errorf("proto: SetReplicationSourceResponse: wiretype end group for non-group")
 13957  		}
 13958  		if fieldNum <= 0 {
 13959  			return fmt.Errorf("proto: SetReplicationSourceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 13960  		}
 13961  		switch fieldNum {
 13962  		default:
 13963  			iNdEx = preIndex
 13964  			skippy, err := skip(dAtA[iNdEx:])
 13965  			if err != nil {
 13966  				return err
 13967  			}
 13968  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 13969  				return ErrInvalidLength
 13970  			}
 13971  			if (iNdEx + skippy) > l {
 13972  				return io.ErrUnexpectedEOF
 13973  			}
 13974  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 13975  			iNdEx += skippy
 13976  		}
 13977  	}
 13978  
 13979  	if iNdEx > l {
 13980  		return io.ErrUnexpectedEOF
 13981  	}
 13982  	return nil
 13983  }
 13984  func (m *ReplicaWasRestartedRequest) UnmarshalVT(dAtA []byte) error {
 13985  	l := len(dAtA)
 13986  	iNdEx := 0
 13987  	for iNdEx < l {
 13988  		preIndex := iNdEx
 13989  		var wire uint64
 13990  		for shift := uint(0); ; shift += 7 {
 13991  			if shift >= 64 {
 13992  				return ErrIntOverflow
 13993  			}
 13994  			if iNdEx >= l {
 13995  				return io.ErrUnexpectedEOF
 13996  			}
 13997  			b := dAtA[iNdEx]
 13998  			iNdEx++
 13999  			wire |= uint64(b&0x7F) << shift
 14000  			if b < 0x80 {
 14001  				break
 14002  			}
 14003  		}
 14004  		fieldNum := int32(wire >> 3)
 14005  		wireType := int(wire & 0x7)
 14006  		if wireType == 4 {
 14007  			return fmt.Errorf("proto: ReplicaWasRestartedRequest: wiretype end group for non-group")
 14008  		}
 14009  		if fieldNum <= 0 {
 14010  			return fmt.Errorf("proto: ReplicaWasRestartedRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14011  		}
 14012  		switch fieldNum {
 14013  		case 1:
 14014  			if wireType != 2 {
 14015  				return fmt.Errorf("proto: wrong wireType = %d for field Parent", wireType)
 14016  			}
 14017  			var msglen int
 14018  			for shift := uint(0); ; shift += 7 {
 14019  				if shift >= 64 {
 14020  					return ErrIntOverflow
 14021  				}
 14022  				if iNdEx >= l {
 14023  					return io.ErrUnexpectedEOF
 14024  				}
 14025  				b := dAtA[iNdEx]
 14026  				iNdEx++
 14027  				msglen |= int(b&0x7F) << shift
 14028  				if b < 0x80 {
 14029  					break
 14030  				}
 14031  			}
 14032  			if msglen < 0 {
 14033  				return ErrInvalidLength
 14034  			}
 14035  			postIndex := iNdEx + msglen
 14036  			if postIndex < 0 {
 14037  				return ErrInvalidLength
 14038  			}
 14039  			if postIndex > l {
 14040  				return io.ErrUnexpectedEOF
 14041  			}
 14042  			if m.Parent == nil {
 14043  				m.Parent = &topodata.TabletAlias{}
 14044  			}
 14045  			if err := m.Parent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14046  				return err
 14047  			}
 14048  			iNdEx = postIndex
 14049  		default:
 14050  			iNdEx = preIndex
 14051  			skippy, err := skip(dAtA[iNdEx:])
 14052  			if err != nil {
 14053  				return err
 14054  			}
 14055  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14056  				return ErrInvalidLength
 14057  			}
 14058  			if (iNdEx + skippy) > l {
 14059  				return io.ErrUnexpectedEOF
 14060  			}
 14061  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14062  			iNdEx += skippy
 14063  		}
 14064  	}
 14065  
 14066  	if iNdEx > l {
 14067  		return io.ErrUnexpectedEOF
 14068  	}
 14069  	return nil
 14070  }
 14071  func (m *ReplicaWasRestartedResponse) UnmarshalVT(dAtA []byte) error {
 14072  	l := len(dAtA)
 14073  	iNdEx := 0
 14074  	for iNdEx < l {
 14075  		preIndex := iNdEx
 14076  		var wire uint64
 14077  		for shift := uint(0); ; shift += 7 {
 14078  			if shift >= 64 {
 14079  				return ErrIntOverflow
 14080  			}
 14081  			if iNdEx >= l {
 14082  				return io.ErrUnexpectedEOF
 14083  			}
 14084  			b := dAtA[iNdEx]
 14085  			iNdEx++
 14086  			wire |= uint64(b&0x7F) << shift
 14087  			if b < 0x80 {
 14088  				break
 14089  			}
 14090  		}
 14091  		fieldNum := int32(wire >> 3)
 14092  		wireType := int(wire & 0x7)
 14093  		if wireType == 4 {
 14094  			return fmt.Errorf("proto: ReplicaWasRestartedResponse: wiretype end group for non-group")
 14095  		}
 14096  		if fieldNum <= 0 {
 14097  			return fmt.Errorf("proto: ReplicaWasRestartedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14098  		}
 14099  		switch fieldNum {
 14100  		default:
 14101  			iNdEx = preIndex
 14102  			skippy, err := skip(dAtA[iNdEx:])
 14103  			if err != nil {
 14104  				return err
 14105  			}
 14106  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14107  				return ErrInvalidLength
 14108  			}
 14109  			if (iNdEx + skippy) > l {
 14110  				return io.ErrUnexpectedEOF
 14111  			}
 14112  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14113  			iNdEx += skippy
 14114  		}
 14115  	}
 14116  
 14117  	if iNdEx > l {
 14118  		return io.ErrUnexpectedEOF
 14119  	}
 14120  	return nil
 14121  }
 14122  func (m *StopReplicationAndGetStatusRequest) UnmarshalVT(dAtA []byte) error {
 14123  	l := len(dAtA)
 14124  	iNdEx := 0
 14125  	for iNdEx < l {
 14126  		preIndex := iNdEx
 14127  		var wire uint64
 14128  		for shift := uint(0); ; shift += 7 {
 14129  			if shift >= 64 {
 14130  				return ErrIntOverflow
 14131  			}
 14132  			if iNdEx >= l {
 14133  				return io.ErrUnexpectedEOF
 14134  			}
 14135  			b := dAtA[iNdEx]
 14136  			iNdEx++
 14137  			wire |= uint64(b&0x7F) << shift
 14138  			if b < 0x80 {
 14139  				break
 14140  			}
 14141  		}
 14142  		fieldNum := int32(wire >> 3)
 14143  		wireType := int(wire & 0x7)
 14144  		if wireType == 4 {
 14145  			return fmt.Errorf("proto: StopReplicationAndGetStatusRequest: wiretype end group for non-group")
 14146  		}
 14147  		if fieldNum <= 0 {
 14148  			return fmt.Errorf("proto: StopReplicationAndGetStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14149  		}
 14150  		switch fieldNum {
 14151  		case 1:
 14152  			if wireType != 0 {
 14153  				return fmt.Errorf("proto: wrong wireType = %d for field StopReplicationMode", wireType)
 14154  			}
 14155  			m.StopReplicationMode = 0
 14156  			for shift := uint(0); ; shift += 7 {
 14157  				if shift >= 64 {
 14158  					return ErrIntOverflow
 14159  				}
 14160  				if iNdEx >= l {
 14161  					return io.ErrUnexpectedEOF
 14162  				}
 14163  				b := dAtA[iNdEx]
 14164  				iNdEx++
 14165  				m.StopReplicationMode |= replicationdata.StopReplicationMode(b&0x7F) << shift
 14166  				if b < 0x80 {
 14167  					break
 14168  				}
 14169  			}
 14170  		default:
 14171  			iNdEx = preIndex
 14172  			skippy, err := skip(dAtA[iNdEx:])
 14173  			if err != nil {
 14174  				return err
 14175  			}
 14176  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14177  				return ErrInvalidLength
 14178  			}
 14179  			if (iNdEx + skippy) > l {
 14180  				return io.ErrUnexpectedEOF
 14181  			}
 14182  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14183  			iNdEx += skippy
 14184  		}
 14185  	}
 14186  
 14187  	if iNdEx > l {
 14188  		return io.ErrUnexpectedEOF
 14189  	}
 14190  	return nil
 14191  }
 14192  func (m *StopReplicationAndGetStatusResponse) UnmarshalVT(dAtA []byte) error {
 14193  	l := len(dAtA)
 14194  	iNdEx := 0
 14195  	for iNdEx < l {
 14196  		preIndex := iNdEx
 14197  		var wire uint64
 14198  		for shift := uint(0); ; shift += 7 {
 14199  			if shift >= 64 {
 14200  				return ErrIntOverflow
 14201  			}
 14202  			if iNdEx >= l {
 14203  				return io.ErrUnexpectedEOF
 14204  			}
 14205  			b := dAtA[iNdEx]
 14206  			iNdEx++
 14207  			wire |= uint64(b&0x7F) << shift
 14208  			if b < 0x80 {
 14209  				break
 14210  			}
 14211  		}
 14212  		fieldNum := int32(wire >> 3)
 14213  		wireType := int(wire & 0x7)
 14214  		if wireType == 4 {
 14215  			return fmt.Errorf("proto: StopReplicationAndGetStatusResponse: wiretype end group for non-group")
 14216  		}
 14217  		if fieldNum <= 0 {
 14218  			return fmt.Errorf("proto: StopReplicationAndGetStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14219  		}
 14220  		switch fieldNum {
 14221  		case 2:
 14222  			if wireType != 2 {
 14223  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 14224  			}
 14225  			var msglen int
 14226  			for shift := uint(0); ; shift += 7 {
 14227  				if shift >= 64 {
 14228  					return ErrIntOverflow
 14229  				}
 14230  				if iNdEx >= l {
 14231  					return io.ErrUnexpectedEOF
 14232  				}
 14233  				b := dAtA[iNdEx]
 14234  				iNdEx++
 14235  				msglen |= int(b&0x7F) << shift
 14236  				if b < 0x80 {
 14237  					break
 14238  				}
 14239  			}
 14240  			if msglen < 0 {
 14241  				return ErrInvalidLength
 14242  			}
 14243  			postIndex := iNdEx + msglen
 14244  			if postIndex < 0 {
 14245  				return ErrInvalidLength
 14246  			}
 14247  			if postIndex > l {
 14248  				return io.ErrUnexpectedEOF
 14249  			}
 14250  			if m.Status == nil {
 14251  				m.Status = &replicationdata.StopReplicationStatus{}
 14252  			}
 14253  			if err := m.Status.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14254  				return err
 14255  			}
 14256  			iNdEx = postIndex
 14257  		default:
 14258  			iNdEx = preIndex
 14259  			skippy, err := skip(dAtA[iNdEx:])
 14260  			if err != nil {
 14261  				return err
 14262  			}
 14263  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14264  				return ErrInvalidLength
 14265  			}
 14266  			if (iNdEx + skippy) > l {
 14267  				return io.ErrUnexpectedEOF
 14268  			}
 14269  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14270  			iNdEx += skippy
 14271  		}
 14272  	}
 14273  
 14274  	if iNdEx > l {
 14275  		return io.ErrUnexpectedEOF
 14276  	}
 14277  	return nil
 14278  }
 14279  func (m *PromoteReplicaRequest) UnmarshalVT(dAtA []byte) error {
 14280  	l := len(dAtA)
 14281  	iNdEx := 0
 14282  	for iNdEx < l {
 14283  		preIndex := iNdEx
 14284  		var wire uint64
 14285  		for shift := uint(0); ; shift += 7 {
 14286  			if shift >= 64 {
 14287  				return ErrIntOverflow
 14288  			}
 14289  			if iNdEx >= l {
 14290  				return io.ErrUnexpectedEOF
 14291  			}
 14292  			b := dAtA[iNdEx]
 14293  			iNdEx++
 14294  			wire |= uint64(b&0x7F) << shift
 14295  			if b < 0x80 {
 14296  				break
 14297  			}
 14298  		}
 14299  		fieldNum := int32(wire >> 3)
 14300  		wireType := int(wire & 0x7)
 14301  		if wireType == 4 {
 14302  			return fmt.Errorf("proto: PromoteReplicaRequest: wiretype end group for non-group")
 14303  		}
 14304  		if fieldNum <= 0 {
 14305  			return fmt.Errorf("proto: PromoteReplicaRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14306  		}
 14307  		switch fieldNum {
 14308  		case 1:
 14309  			if wireType != 0 {
 14310  				return fmt.Errorf("proto: wrong wireType = %d for field SemiSync", wireType)
 14311  			}
 14312  			var v int
 14313  			for shift := uint(0); ; shift += 7 {
 14314  				if shift >= 64 {
 14315  					return ErrIntOverflow
 14316  				}
 14317  				if iNdEx >= l {
 14318  					return io.ErrUnexpectedEOF
 14319  				}
 14320  				b := dAtA[iNdEx]
 14321  				iNdEx++
 14322  				v |= int(b&0x7F) << shift
 14323  				if b < 0x80 {
 14324  					break
 14325  				}
 14326  			}
 14327  			m.SemiSync = bool(v != 0)
 14328  		default:
 14329  			iNdEx = preIndex
 14330  			skippy, err := skip(dAtA[iNdEx:])
 14331  			if err != nil {
 14332  				return err
 14333  			}
 14334  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14335  				return ErrInvalidLength
 14336  			}
 14337  			if (iNdEx + skippy) > l {
 14338  				return io.ErrUnexpectedEOF
 14339  			}
 14340  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14341  			iNdEx += skippy
 14342  		}
 14343  	}
 14344  
 14345  	if iNdEx > l {
 14346  		return io.ErrUnexpectedEOF
 14347  	}
 14348  	return nil
 14349  }
 14350  func (m *PromoteReplicaResponse) UnmarshalVT(dAtA []byte) error {
 14351  	l := len(dAtA)
 14352  	iNdEx := 0
 14353  	for iNdEx < l {
 14354  		preIndex := iNdEx
 14355  		var wire uint64
 14356  		for shift := uint(0); ; shift += 7 {
 14357  			if shift >= 64 {
 14358  				return ErrIntOverflow
 14359  			}
 14360  			if iNdEx >= l {
 14361  				return io.ErrUnexpectedEOF
 14362  			}
 14363  			b := dAtA[iNdEx]
 14364  			iNdEx++
 14365  			wire |= uint64(b&0x7F) << shift
 14366  			if b < 0x80 {
 14367  				break
 14368  			}
 14369  		}
 14370  		fieldNum := int32(wire >> 3)
 14371  		wireType := int(wire & 0x7)
 14372  		if wireType == 4 {
 14373  			return fmt.Errorf("proto: PromoteReplicaResponse: wiretype end group for non-group")
 14374  		}
 14375  		if fieldNum <= 0 {
 14376  			return fmt.Errorf("proto: PromoteReplicaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14377  		}
 14378  		switch fieldNum {
 14379  		case 1:
 14380  			if wireType != 2 {
 14381  				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
 14382  			}
 14383  			var stringLen uint64
 14384  			for shift := uint(0); ; shift += 7 {
 14385  				if shift >= 64 {
 14386  					return ErrIntOverflow
 14387  				}
 14388  				if iNdEx >= l {
 14389  					return io.ErrUnexpectedEOF
 14390  				}
 14391  				b := dAtA[iNdEx]
 14392  				iNdEx++
 14393  				stringLen |= uint64(b&0x7F) << shift
 14394  				if b < 0x80 {
 14395  					break
 14396  				}
 14397  			}
 14398  			intStringLen := int(stringLen)
 14399  			if intStringLen < 0 {
 14400  				return ErrInvalidLength
 14401  			}
 14402  			postIndex := iNdEx + intStringLen
 14403  			if postIndex < 0 {
 14404  				return ErrInvalidLength
 14405  			}
 14406  			if postIndex > l {
 14407  				return io.ErrUnexpectedEOF
 14408  			}
 14409  			m.Position = string(dAtA[iNdEx:postIndex])
 14410  			iNdEx = postIndex
 14411  		default:
 14412  			iNdEx = preIndex
 14413  			skippy, err := skip(dAtA[iNdEx:])
 14414  			if err != nil {
 14415  				return err
 14416  			}
 14417  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14418  				return ErrInvalidLength
 14419  			}
 14420  			if (iNdEx + skippy) > l {
 14421  				return io.ErrUnexpectedEOF
 14422  			}
 14423  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14424  			iNdEx += skippy
 14425  		}
 14426  	}
 14427  
 14428  	if iNdEx > l {
 14429  		return io.ErrUnexpectedEOF
 14430  	}
 14431  	return nil
 14432  }
 14433  func (m *BackupRequest) UnmarshalVT(dAtA []byte) error {
 14434  	l := len(dAtA)
 14435  	iNdEx := 0
 14436  	for iNdEx < l {
 14437  		preIndex := iNdEx
 14438  		var wire uint64
 14439  		for shift := uint(0); ; shift += 7 {
 14440  			if shift >= 64 {
 14441  				return ErrIntOverflow
 14442  			}
 14443  			if iNdEx >= l {
 14444  				return io.ErrUnexpectedEOF
 14445  			}
 14446  			b := dAtA[iNdEx]
 14447  			iNdEx++
 14448  			wire |= uint64(b&0x7F) << shift
 14449  			if b < 0x80 {
 14450  				break
 14451  			}
 14452  		}
 14453  		fieldNum := int32(wire >> 3)
 14454  		wireType := int(wire & 0x7)
 14455  		if wireType == 4 {
 14456  			return fmt.Errorf("proto: BackupRequest: wiretype end group for non-group")
 14457  		}
 14458  		if fieldNum <= 0 {
 14459  			return fmt.Errorf("proto: BackupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14460  		}
 14461  		switch fieldNum {
 14462  		case 1:
 14463  			if wireType != 0 {
 14464  				return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType)
 14465  			}
 14466  			m.Concurrency = 0
 14467  			for shift := uint(0); ; shift += 7 {
 14468  				if shift >= 64 {
 14469  					return ErrIntOverflow
 14470  				}
 14471  				if iNdEx >= l {
 14472  					return io.ErrUnexpectedEOF
 14473  				}
 14474  				b := dAtA[iNdEx]
 14475  				iNdEx++
 14476  				m.Concurrency |= int64(b&0x7F) << shift
 14477  				if b < 0x80 {
 14478  					break
 14479  				}
 14480  			}
 14481  		case 2:
 14482  			if wireType != 0 {
 14483  				return fmt.Errorf("proto: wrong wireType = %d for field AllowPrimary", wireType)
 14484  			}
 14485  			var v int
 14486  			for shift := uint(0); ; shift += 7 {
 14487  				if shift >= 64 {
 14488  					return ErrIntOverflow
 14489  				}
 14490  				if iNdEx >= l {
 14491  					return io.ErrUnexpectedEOF
 14492  				}
 14493  				b := dAtA[iNdEx]
 14494  				iNdEx++
 14495  				v |= int(b&0x7F) << shift
 14496  				if b < 0x80 {
 14497  					break
 14498  				}
 14499  			}
 14500  			m.AllowPrimary = bool(v != 0)
 14501  		case 3:
 14502  			if wireType != 2 {
 14503  				return fmt.Errorf("proto: wrong wireType = %d for field IncrementalFromPos", wireType)
 14504  			}
 14505  			var stringLen uint64
 14506  			for shift := uint(0); ; shift += 7 {
 14507  				if shift >= 64 {
 14508  					return ErrIntOverflow
 14509  				}
 14510  				if iNdEx >= l {
 14511  					return io.ErrUnexpectedEOF
 14512  				}
 14513  				b := dAtA[iNdEx]
 14514  				iNdEx++
 14515  				stringLen |= uint64(b&0x7F) << shift
 14516  				if b < 0x80 {
 14517  					break
 14518  				}
 14519  			}
 14520  			intStringLen := int(stringLen)
 14521  			if intStringLen < 0 {
 14522  				return ErrInvalidLength
 14523  			}
 14524  			postIndex := iNdEx + intStringLen
 14525  			if postIndex < 0 {
 14526  				return ErrInvalidLength
 14527  			}
 14528  			if postIndex > l {
 14529  				return io.ErrUnexpectedEOF
 14530  			}
 14531  			m.IncrementalFromPos = string(dAtA[iNdEx:postIndex])
 14532  			iNdEx = postIndex
 14533  		default:
 14534  			iNdEx = preIndex
 14535  			skippy, err := skip(dAtA[iNdEx:])
 14536  			if err != nil {
 14537  				return err
 14538  			}
 14539  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14540  				return ErrInvalidLength
 14541  			}
 14542  			if (iNdEx + skippy) > l {
 14543  				return io.ErrUnexpectedEOF
 14544  			}
 14545  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14546  			iNdEx += skippy
 14547  		}
 14548  	}
 14549  
 14550  	if iNdEx > l {
 14551  		return io.ErrUnexpectedEOF
 14552  	}
 14553  	return nil
 14554  }
 14555  func (m *BackupResponse) UnmarshalVT(dAtA []byte) error {
 14556  	l := len(dAtA)
 14557  	iNdEx := 0
 14558  	for iNdEx < l {
 14559  		preIndex := iNdEx
 14560  		var wire uint64
 14561  		for shift := uint(0); ; shift += 7 {
 14562  			if shift >= 64 {
 14563  				return ErrIntOverflow
 14564  			}
 14565  			if iNdEx >= l {
 14566  				return io.ErrUnexpectedEOF
 14567  			}
 14568  			b := dAtA[iNdEx]
 14569  			iNdEx++
 14570  			wire |= uint64(b&0x7F) << shift
 14571  			if b < 0x80 {
 14572  				break
 14573  			}
 14574  		}
 14575  		fieldNum := int32(wire >> 3)
 14576  		wireType := int(wire & 0x7)
 14577  		if wireType == 4 {
 14578  			return fmt.Errorf("proto: BackupResponse: wiretype end group for non-group")
 14579  		}
 14580  		if fieldNum <= 0 {
 14581  			return fmt.Errorf("proto: BackupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14582  		}
 14583  		switch fieldNum {
 14584  		case 1:
 14585  			if wireType != 2 {
 14586  				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
 14587  			}
 14588  			var msglen int
 14589  			for shift := uint(0); ; shift += 7 {
 14590  				if shift >= 64 {
 14591  					return ErrIntOverflow
 14592  				}
 14593  				if iNdEx >= l {
 14594  					return io.ErrUnexpectedEOF
 14595  				}
 14596  				b := dAtA[iNdEx]
 14597  				iNdEx++
 14598  				msglen |= int(b&0x7F) << shift
 14599  				if b < 0x80 {
 14600  					break
 14601  				}
 14602  			}
 14603  			if msglen < 0 {
 14604  				return ErrInvalidLength
 14605  			}
 14606  			postIndex := iNdEx + msglen
 14607  			if postIndex < 0 {
 14608  				return ErrInvalidLength
 14609  			}
 14610  			if postIndex > l {
 14611  				return io.ErrUnexpectedEOF
 14612  			}
 14613  			if m.Event == nil {
 14614  				m.Event = &logutil.Event{}
 14615  			}
 14616  			if err := m.Event.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14617  				return err
 14618  			}
 14619  			iNdEx = postIndex
 14620  		default:
 14621  			iNdEx = preIndex
 14622  			skippy, err := skip(dAtA[iNdEx:])
 14623  			if err != nil {
 14624  				return err
 14625  			}
 14626  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14627  				return ErrInvalidLength
 14628  			}
 14629  			if (iNdEx + skippy) > l {
 14630  				return io.ErrUnexpectedEOF
 14631  			}
 14632  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14633  			iNdEx += skippy
 14634  		}
 14635  	}
 14636  
 14637  	if iNdEx > l {
 14638  		return io.ErrUnexpectedEOF
 14639  	}
 14640  	return nil
 14641  }
 14642  func (m *RestoreFromBackupRequest) UnmarshalVT(dAtA []byte) error {
 14643  	l := len(dAtA)
 14644  	iNdEx := 0
 14645  	for iNdEx < l {
 14646  		preIndex := iNdEx
 14647  		var wire uint64
 14648  		for shift := uint(0); ; shift += 7 {
 14649  			if shift >= 64 {
 14650  				return ErrIntOverflow
 14651  			}
 14652  			if iNdEx >= l {
 14653  				return io.ErrUnexpectedEOF
 14654  			}
 14655  			b := dAtA[iNdEx]
 14656  			iNdEx++
 14657  			wire |= uint64(b&0x7F) << shift
 14658  			if b < 0x80 {
 14659  				break
 14660  			}
 14661  		}
 14662  		fieldNum := int32(wire >> 3)
 14663  		wireType := int(wire & 0x7)
 14664  		if wireType == 4 {
 14665  			return fmt.Errorf("proto: RestoreFromBackupRequest: wiretype end group for non-group")
 14666  		}
 14667  		if fieldNum <= 0 {
 14668  			return fmt.Errorf("proto: RestoreFromBackupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14669  		}
 14670  		switch fieldNum {
 14671  		case 1:
 14672  			if wireType != 2 {
 14673  				return fmt.Errorf("proto: wrong wireType = %d for field BackupTime", wireType)
 14674  			}
 14675  			var msglen int
 14676  			for shift := uint(0); ; shift += 7 {
 14677  				if shift >= 64 {
 14678  					return ErrIntOverflow
 14679  				}
 14680  				if iNdEx >= l {
 14681  					return io.ErrUnexpectedEOF
 14682  				}
 14683  				b := dAtA[iNdEx]
 14684  				iNdEx++
 14685  				msglen |= int(b&0x7F) << shift
 14686  				if b < 0x80 {
 14687  					break
 14688  				}
 14689  			}
 14690  			if msglen < 0 {
 14691  				return ErrInvalidLength
 14692  			}
 14693  			postIndex := iNdEx + msglen
 14694  			if postIndex < 0 {
 14695  				return ErrInvalidLength
 14696  			}
 14697  			if postIndex > l {
 14698  				return io.ErrUnexpectedEOF
 14699  			}
 14700  			if m.BackupTime == nil {
 14701  				m.BackupTime = &vttime.Time{}
 14702  			}
 14703  			if err := m.BackupTime.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14704  				return err
 14705  			}
 14706  			iNdEx = postIndex
 14707  		case 2:
 14708  			if wireType != 2 {
 14709  				return fmt.Errorf("proto: wrong wireType = %d for field RestoreToPos", wireType)
 14710  			}
 14711  			var stringLen uint64
 14712  			for shift := uint(0); ; shift += 7 {
 14713  				if shift >= 64 {
 14714  					return ErrIntOverflow
 14715  				}
 14716  				if iNdEx >= l {
 14717  					return io.ErrUnexpectedEOF
 14718  				}
 14719  				b := dAtA[iNdEx]
 14720  				iNdEx++
 14721  				stringLen |= uint64(b&0x7F) << shift
 14722  				if b < 0x80 {
 14723  					break
 14724  				}
 14725  			}
 14726  			intStringLen := int(stringLen)
 14727  			if intStringLen < 0 {
 14728  				return ErrInvalidLength
 14729  			}
 14730  			postIndex := iNdEx + intStringLen
 14731  			if postIndex < 0 {
 14732  				return ErrInvalidLength
 14733  			}
 14734  			if postIndex > l {
 14735  				return io.ErrUnexpectedEOF
 14736  			}
 14737  			m.RestoreToPos = string(dAtA[iNdEx:postIndex])
 14738  			iNdEx = postIndex
 14739  		case 3:
 14740  			if wireType != 0 {
 14741  				return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
 14742  			}
 14743  			var v int
 14744  			for shift := uint(0); ; shift += 7 {
 14745  				if shift >= 64 {
 14746  					return ErrIntOverflow
 14747  				}
 14748  				if iNdEx >= l {
 14749  					return io.ErrUnexpectedEOF
 14750  				}
 14751  				b := dAtA[iNdEx]
 14752  				iNdEx++
 14753  				v |= int(b&0x7F) << shift
 14754  				if b < 0x80 {
 14755  					break
 14756  				}
 14757  			}
 14758  			m.DryRun = bool(v != 0)
 14759  		default:
 14760  			iNdEx = preIndex
 14761  			skippy, err := skip(dAtA[iNdEx:])
 14762  			if err != nil {
 14763  				return err
 14764  			}
 14765  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14766  				return ErrInvalidLength
 14767  			}
 14768  			if (iNdEx + skippy) > l {
 14769  				return io.ErrUnexpectedEOF
 14770  			}
 14771  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14772  			iNdEx += skippy
 14773  		}
 14774  	}
 14775  
 14776  	if iNdEx > l {
 14777  		return io.ErrUnexpectedEOF
 14778  	}
 14779  	return nil
 14780  }
 14781  func (m *RestoreFromBackupResponse) UnmarshalVT(dAtA []byte) error {
 14782  	l := len(dAtA)
 14783  	iNdEx := 0
 14784  	for iNdEx < l {
 14785  		preIndex := iNdEx
 14786  		var wire uint64
 14787  		for shift := uint(0); ; shift += 7 {
 14788  			if shift >= 64 {
 14789  				return ErrIntOverflow
 14790  			}
 14791  			if iNdEx >= l {
 14792  				return io.ErrUnexpectedEOF
 14793  			}
 14794  			b := dAtA[iNdEx]
 14795  			iNdEx++
 14796  			wire |= uint64(b&0x7F) << shift
 14797  			if b < 0x80 {
 14798  				break
 14799  			}
 14800  		}
 14801  		fieldNum := int32(wire >> 3)
 14802  		wireType := int(wire & 0x7)
 14803  		if wireType == 4 {
 14804  			return fmt.Errorf("proto: RestoreFromBackupResponse: wiretype end group for non-group")
 14805  		}
 14806  		if fieldNum <= 0 {
 14807  			return fmt.Errorf("proto: RestoreFromBackupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 14808  		}
 14809  		switch fieldNum {
 14810  		case 1:
 14811  			if wireType != 2 {
 14812  				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
 14813  			}
 14814  			var msglen int
 14815  			for shift := uint(0); ; shift += 7 {
 14816  				if shift >= 64 {
 14817  					return ErrIntOverflow
 14818  				}
 14819  				if iNdEx >= l {
 14820  					return io.ErrUnexpectedEOF
 14821  				}
 14822  				b := dAtA[iNdEx]
 14823  				iNdEx++
 14824  				msglen |= int(b&0x7F) << shift
 14825  				if b < 0x80 {
 14826  					break
 14827  				}
 14828  			}
 14829  			if msglen < 0 {
 14830  				return ErrInvalidLength
 14831  			}
 14832  			postIndex := iNdEx + msglen
 14833  			if postIndex < 0 {
 14834  				return ErrInvalidLength
 14835  			}
 14836  			if postIndex > l {
 14837  				return io.ErrUnexpectedEOF
 14838  			}
 14839  			if m.Event == nil {
 14840  				m.Event = &logutil.Event{}
 14841  			}
 14842  			if err := m.Event.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 14843  				return err
 14844  			}
 14845  			iNdEx = postIndex
 14846  		default:
 14847  			iNdEx = preIndex
 14848  			skippy, err := skip(dAtA[iNdEx:])
 14849  			if err != nil {
 14850  				return err
 14851  			}
 14852  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 14853  				return ErrInvalidLength
 14854  			}
 14855  			if (iNdEx + skippy) > l {
 14856  				return io.ErrUnexpectedEOF
 14857  			}
 14858  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 14859  			iNdEx += skippy
 14860  		}
 14861  	}
 14862  
 14863  	if iNdEx > l {
 14864  		return io.ErrUnexpectedEOF
 14865  	}
 14866  	return nil
 14867  }
 14868  func (m *VExecRequest) UnmarshalVT(dAtA []byte) error {
 14869  	l := len(dAtA)
 14870  	iNdEx := 0
 14871  	for iNdEx < l {
 14872  		preIndex := iNdEx
 14873  		var wire uint64
 14874  		for shift := uint(0); ; shift += 7 {
 14875  			if shift >= 64 {
 14876  				return ErrIntOverflow
 14877  			}
 14878  			if iNdEx >= l {
 14879  				return io.ErrUnexpectedEOF
 14880  			}
 14881  			b := dAtA[iNdEx]
 14882  			iNdEx++
 14883  			wire |= uint64(b&0x7F) << shift
 14884  			if b < 0x80 {
 14885  				break
 14886  			}
 14887  		}
 14888  		fieldNum := int32(wire >> 3)
 14889  		wireType := int(wire & 0x7)
 14890  		if wireType == 4 {
 14891  			return fmt.Errorf("proto: VExecRequest: wiretype end group for non-group")
 14892  		}
 14893  		if fieldNum <= 0 {
 14894  			return fmt.Errorf("proto: VExecRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 14895  		}
 14896  		switch fieldNum {
 14897  		case 1:
 14898  			if wireType != 2 {
 14899  				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
 14900  			}
 14901  			var stringLen uint64
 14902  			for shift := uint(0); ; shift += 7 {
 14903  				if shift >= 64 {
 14904  					return ErrIntOverflow
 14905  				}
 14906  				if iNdEx >= l {
 14907  					return io.ErrUnexpectedEOF
 14908  				}
 14909  				b := dAtA[iNdEx]
 14910  				iNdEx++
 14911  				stringLen |= uint64(b&0x7F) << shift
 14912  				if b < 0x80 {
 14913  					break
 14914  				}
 14915  			}
 14916  			intStringLen := int(stringLen)
 14917  			if intStringLen < 0 {
 14918  				return ErrInvalidLength
 14919  			}
 14920  			postIndex := iNdEx + intStringLen
 14921  			if postIndex < 0 {
 14922  				return ErrInvalidLength
 14923  			}
 14924  			if postIndex > l {
 14925  				return io.ErrUnexpectedEOF
 14926  			}
 14927  			m.Query = string(dAtA[iNdEx:postIndex])
 14928  			iNdEx = postIndex
 14929  		case 2:
 14930  			if wireType != 2 {
 14931  				return fmt.Errorf("proto: wrong wireType = %d for field Workflow", wireType)
 14932  			}
 14933  			var stringLen uint64
 14934  			for shift := uint(0); ; shift += 7 {
 14935  				if shift >= 64 {
 14936  					return ErrIntOverflow
 14937  				}
 14938  				if iNdEx >= l {
 14939  					return io.ErrUnexpectedEOF
 14940  				}
 14941  				b := dAtA[iNdEx]
 14942  				iNdEx++
 14943  				stringLen |= uint64(b&0x7F) << shift
 14944  				if b < 0x80 {
 14945  					break
 14946  				}
 14947  			}
 14948  			intStringLen := int(stringLen)
 14949  			if intStringLen < 0 {
 14950  				return ErrInvalidLength
 14951  			}
 14952  			postIndex := iNdEx + intStringLen
 14953  			if postIndex < 0 {
 14954  				return ErrInvalidLength
 14955  			}
 14956  			if postIndex > l {
 14957  				return io.ErrUnexpectedEOF
 14958  			}
 14959  			m.Workflow = string(dAtA[iNdEx:postIndex])
 14960  			iNdEx = postIndex
 14961  		case 3:
 14962  			if wireType != 2 {
 14963  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 14964  			}
 14965  			var stringLen uint64
 14966  			for shift := uint(0); ; shift += 7 {
 14967  				if shift >= 64 {
 14968  					return ErrIntOverflow
 14969  				}
 14970  				if iNdEx >= l {
 14971  					return io.ErrUnexpectedEOF
 14972  				}
 14973  				b := dAtA[iNdEx]
 14974  				iNdEx++
 14975  				stringLen |= uint64(b&0x7F) << shift
 14976  				if b < 0x80 {
 14977  					break
 14978  				}
 14979  			}
 14980  			intStringLen := int(stringLen)
 14981  			if intStringLen < 0 {
 14982  				return ErrInvalidLength
 14983  			}
 14984  			postIndex := iNdEx + intStringLen
 14985  			if postIndex < 0 {
 14986  				return ErrInvalidLength
 14987  			}
 14988  			if postIndex > l {
 14989  				return io.ErrUnexpectedEOF
 14990  			}
 14991  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 14992  			iNdEx = postIndex
 14993  		default:
 14994  			iNdEx = preIndex
 14995  			skippy, err := skip(dAtA[iNdEx:])
 14996  			if err != nil {
 14997  				return err
 14998  			}
 14999  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15000  				return ErrInvalidLength
 15001  			}
 15002  			if (iNdEx + skippy) > l {
 15003  				return io.ErrUnexpectedEOF
 15004  			}
 15005  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15006  			iNdEx += skippy
 15007  		}
 15008  	}
 15009  
 15010  	if iNdEx > l {
 15011  		return io.ErrUnexpectedEOF
 15012  	}
 15013  	return nil
 15014  }
 15015  func (m *VExecResponse) UnmarshalVT(dAtA []byte) error {
 15016  	l := len(dAtA)
 15017  	iNdEx := 0
 15018  	for iNdEx < l {
 15019  		preIndex := iNdEx
 15020  		var wire uint64
 15021  		for shift := uint(0); ; shift += 7 {
 15022  			if shift >= 64 {
 15023  				return ErrIntOverflow
 15024  			}
 15025  			if iNdEx >= l {
 15026  				return io.ErrUnexpectedEOF
 15027  			}
 15028  			b := dAtA[iNdEx]
 15029  			iNdEx++
 15030  			wire |= uint64(b&0x7F) << shift
 15031  			if b < 0x80 {
 15032  				break
 15033  			}
 15034  		}
 15035  		fieldNum := int32(wire >> 3)
 15036  		wireType := int(wire & 0x7)
 15037  		if wireType == 4 {
 15038  			return fmt.Errorf("proto: VExecResponse: wiretype end group for non-group")
 15039  		}
 15040  		if fieldNum <= 0 {
 15041  			return fmt.Errorf("proto: VExecResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15042  		}
 15043  		switch fieldNum {
 15044  		case 1:
 15045  			if wireType != 2 {
 15046  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 15047  			}
 15048  			var msglen int
 15049  			for shift := uint(0); ; shift += 7 {
 15050  				if shift >= 64 {
 15051  					return ErrIntOverflow
 15052  				}
 15053  				if iNdEx >= l {
 15054  					return io.ErrUnexpectedEOF
 15055  				}
 15056  				b := dAtA[iNdEx]
 15057  				iNdEx++
 15058  				msglen |= int(b&0x7F) << shift
 15059  				if b < 0x80 {
 15060  					break
 15061  				}
 15062  			}
 15063  			if msglen < 0 {
 15064  				return ErrInvalidLength
 15065  			}
 15066  			postIndex := iNdEx + msglen
 15067  			if postIndex < 0 {
 15068  				return ErrInvalidLength
 15069  			}
 15070  			if postIndex > l {
 15071  				return io.ErrUnexpectedEOF
 15072  			}
 15073  			if m.Result == nil {
 15074  				m.Result = &query.QueryResult{}
 15075  			}
 15076  			if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15077  				return err
 15078  			}
 15079  			iNdEx = postIndex
 15080  		default:
 15081  			iNdEx = preIndex
 15082  			skippy, err := skip(dAtA[iNdEx:])
 15083  			if err != nil {
 15084  				return err
 15085  			}
 15086  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15087  				return ErrInvalidLength
 15088  			}
 15089  			if (iNdEx + skippy) > l {
 15090  				return io.ErrUnexpectedEOF
 15091  			}
 15092  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15093  			iNdEx += skippy
 15094  		}
 15095  	}
 15096  
 15097  	if iNdEx > l {
 15098  		return io.ErrUnexpectedEOF
 15099  	}
 15100  	return nil
 15101  }
 15102  func (m *VDiffRequest) UnmarshalVT(dAtA []byte) error {
 15103  	l := len(dAtA)
 15104  	iNdEx := 0
 15105  	for iNdEx < l {
 15106  		preIndex := iNdEx
 15107  		var wire uint64
 15108  		for shift := uint(0); ; shift += 7 {
 15109  			if shift >= 64 {
 15110  				return ErrIntOverflow
 15111  			}
 15112  			if iNdEx >= l {
 15113  				return io.ErrUnexpectedEOF
 15114  			}
 15115  			b := dAtA[iNdEx]
 15116  			iNdEx++
 15117  			wire |= uint64(b&0x7F) << shift
 15118  			if b < 0x80 {
 15119  				break
 15120  			}
 15121  		}
 15122  		fieldNum := int32(wire >> 3)
 15123  		wireType := int(wire & 0x7)
 15124  		if wireType == 4 {
 15125  			return fmt.Errorf("proto: VDiffRequest: wiretype end group for non-group")
 15126  		}
 15127  		if fieldNum <= 0 {
 15128  			return fmt.Errorf("proto: VDiffRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 15129  		}
 15130  		switch fieldNum {
 15131  		case 1:
 15132  			if wireType != 2 {
 15133  				return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType)
 15134  			}
 15135  			var stringLen uint64
 15136  			for shift := uint(0); ; shift += 7 {
 15137  				if shift >= 64 {
 15138  					return ErrIntOverflow
 15139  				}
 15140  				if iNdEx >= l {
 15141  					return io.ErrUnexpectedEOF
 15142  				}
 15143  				b := dAtA[iNdEx]
 15144  				iNdEx++
 15145  				stringLen |= uint64(b&0x7F) << shift
 15146  				if b < 0x80 {
 15147  					break
 15148  				}
 15149  			}
 15150  			intStringLen := int(stringLen)
 15151  			if intStringLen < 0 {
 15152  				return ErrInvalidLength
 15153  			}
 15154  			postIndex := iNdEx + intStringLen
 15155  			if postIndex < 0 {
 15156  				return ErrInvalidLength
 15157  			}
 15158  			if postIndex > l {
 15159  				return io.ErrUnexpectedEOF
 15160  			}
 15161  			m.Keyspace = string(dAtA[iNdEx:postIndex])
 15162  			iNdEx = postIndex
 15163  		case 2:
 15164  			if wireType != 2 {
 15165  				return fmt.Errorf("proto: wrong wireType = %d for field Workflow", wireType)
 15166  			}
 15167  			var stringLen uint64
 15168  			for shift := uint(0); ; shift += 7 {
 15169  				if shift >= 64 {
 15170  					return ErrIntOverflow
 15171  				}
 15172  				if iNdEx >= l {
 15173  					return io.ErrUnexpectedEOF
 15174  				}
 15175  				b := dAtA[iNdEx]
 15176  				iNdEx++
 15177  				stringLen |= uint64(b&0x7F) << shift
 15178  				if b < 0x80 {
 15179  					break
 15180  				}
 15181  			}
 15182  			intStringLen := int(stringLen)
 15183  			if intStringLen < 0 {
 15184  				return ErrInvalidLength
 15185  			}
 15186  			postIndex := iNdEx + intStringLen
 15187  			if postIndex < 0 {
 15188  				return ErrInvalidLength
 15189  			}
 15190  			if postIndex > l {
 15191  				return io.ErrUnexpectedEOF
 15192  			}
 15193  			m.Workflow = string(dAtA[iNdEx:postIndex])
 15194  			iNdEx = postIndex
 15195  		case 3:
 15196  			if wireType != 2 {
 15197  				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
 15198  			}
 15199  			var stringLen uint64
 15200  			for shift := uint(0); ; shift += 7 {
 15201  				if shift >= 64 {
 15202  					return ErrIntOverflow
 15203  				}
 15204  				if iNdEx >= l {
 15205  					return io.ErrUnexpectedEOF
 15206  				}
 15207  				b := dAtA[iNdEx]
 15208  				iNdEx++
 15209  				stringLen |= uint64(b&0x7F) << shift
 15210  				if b < 0x80 {
 15211  					break
 15212  				}
 15213  			}
 15214  			intStringLen := int(stringLen)
 15215  			if intStringLen < 0 {
 15216  				return ErrInvalidLength
 15217  			}
 15218  			postIndex := iNdEx + intStringLen
 15219  			if postIndex < 0 {
 15220  				return ErrInvalidLength
 15221  			}
 15222  			if postIndex > l {
 15223  				return io.ErrUnexpectedEOF
 15224  			}
 15225  			m.Action = string(dAtA[iNdEx:postIndex])
 15226  			iNdEx = postIndex
 15227  		case 4:
 15228  			if wireType != 2 {
 15229  				return fmt.Errorf("proto: wrong wireType = %d for field ActionArg", wireType)
 15230  			}
 15231  			var stringLen uint64
 15232  			for shift := uint(0); ; shift += 7 {
 15233  				if shift >= 64 {
 15234  					return ErrIntOverflow
 15235  				}
 15236  				if iNdEx >= l {
 15237  					return io.ErrUnexpectedEOF
 15238  				}
 15239  				b := dAtA[iNdEx]
 15240  				iNdEx++
 15241  				stringLen |= uint64(b&0x7F) << shift
 15242  				if b < 0x80 {
 15243  					break
 15244  				}
 15245  			}
 15246  			intStringLen := int(stringLen)
 15247  			if intStringLen < 0 {
 15248  				return ErrInvalidLength
 15249  			}
 15250  			postIndex := iNdEx + intStringLen
 15251  			if postIndex < 0 {
 15252  				return ErrInvalidLength
 15253  			}
 15254  			if postIndex > l {
 15255  				return io.ErrUnexpectedEOF
 15256  			}
 15257  			m.ActionArg = string(dAtA[iNdEx:postIndex])
 15258  			iNdEx = postIndex
 15259  		case 5:
 15260  			if wireType != 2 {
 15261  				return fmt.Errorf("proto: wrong wireType = %d for field VdiffUuid", wireType)
 15262  			}
 15263  			var stringLen uint64
 15264  			for shift := uint(0); ; shift += 7 {
 15265  				if shift >= 64 {
 15266  					return ErrIntOverflow
 15267  				}
 15268  				if iNdEx >= l {
 15269  					return io.ErrUnexpectedEOF
 15270  				}
 15271  				b := dAtA[iNdEx]
 15272  				iNdEx++
 15273  				stringLen |= uint64(b&0x7F) << shift
 15274  				if b < 0x80 {
 15275  					break
 15276  				}
 15277  			}
 15278  			intStringLen := int(stringLen)
 15279  			if intStringLen < 0 {
 15280  				return ErrInvalidLength
 15281  			}
 15282  			postIndex := iNdEx + intStringLen
 15283  			if postIndex < 0 {
 15284  				return ErrInvalidLength
 15285  			}
 15286  			if postIndex > l {
 15287  				return io.ErrUnexpectedEOF
 15288  			}
 15289  			m.VdiffUuid = string(dAtA[iNdEx:postIndex])
 15290  			iNdEx = postIndex
 15291  		case 6:
 15292  			if wireType != 2 {
 15293  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
 15294  			}
 15295  			var msglen int
 15296  			for shift := uint(0); ; shift += 7 {
 15297  				if shift >= 64 {
 15298  					return ErrIntOverflow
 15299  				}
 15300  				if iNdEx >= l {
 15301  					return io.ErrUnexpectedEOF
 15302  				}
 15303  				b := dAtA[iNdEx]
 15304  				iNdEx++
 15305  				msglen |= int(b&0x7F) << shift
 15306  				if b < 0x80 {
 15307  					break
 15308  				}
 15309  			}
 15310  			if msglen < 0 {
 15311  				return ErrInvalidLength
 15312  			}
 15313  			postIndex := iNdEx + msglen
 15314  			if postIndex < 0 {
 15315  				return ErrInvalidLength
 15316  			}
 15317  			if postIndex > l {
 15318  				return io.ErrUnexpectedEOF
 15319  			}
 15320  			if m.Options == nil {
 15321  				m.Options = &VDiffOptions{}
 15322  			}
 15323  			if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15324  				return err
 15325  			}
 15326  			iNdEx = postIndex
 15327  		default:
 15328  			iNdEx = preIndex
 15329  			skippy, err := skip(dAtA[iNdEx:])
 15330  			if err != nil {
 15331  				return err
 15332  			}
 15333  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15334  				return ErrInvalidLength
 15335  			}
 15336  			if (iNdEx + skippy) > l {
 15337  				return io.ErrUnexpectedEOF
 15338  			}
 15339  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15340  			iNdEx += skippy
 15341  		}
 15342  	}
 15343  
 15344  	if iNdEx > l {
 15345  		return io.ErrUnexpectedEOF
 15346  	}
 15347  	return nil
 15348  }
 15349  func (m *VDiffResponse) UnmarshalVT(dAtA []byte) error {
 15350  	l := len(dAtA)
 15351  	iNdEx := 0
 15352  	for iNdEx < l {
 15353  		preIndex := iNdEx
 15354  		var wire uint64
 15355  		for shift := uint(0); ; shift += 7 {
 15356  			if shift >= 64 {
 15357  				return ErrIntOverflow
 15358  			}
 15359  			if iNdEx >= l {
 15360  				return io.ErrUnexpectedEOF
 15361  			}
 15362  			b := dAtA[iNdEx]
 15363  			iNdEx++
 15364  			wire |= uint64(b&0x7F) << shift
 15365  			if b < 0x80 {
 15366  				break
 15367  			}
 15368  		}
 15369  		fieldNum := int32(wire >> 3)
 15370  		wireType := int(wire & 0x7)
 15371  		if wireType == 4 {
 15372  			return fmt.Errorf("proto: VDiffResponse: wiretype end group for non-group")
 15373  		}
 15374  		if fieldNum <= 0 {
 15375  			return fmt.Errorf("proto: VDiffResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 15376  		}
 15377  		switch fieldNum {
 15378  		case 1:
 15379  			if wireType != 0 {
 15380  				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
 15381  			}
 15382  			m.Id = 0
 15383  			for shift := uint(0); ; shift += 7 {
 15384  				if shift >= 64 {
 15385  					return ErrIntOverflow
 15386  				}
 15387  				if iNdEx >= l {
 15388  					return io.ErrUnexpectedEOF
 15389  				}
 15390  				b := dAtA[iNdEx]
 15391  				iNdEx++
 15392  				m.Id |= int64(b&0x7F) << shift
 15393  				if b < 0x80 {
 15394  					break
 15395  				}
 15396  			}
 15397  		case 2:
 15398  			if wireType != 2 {
 15399  				return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
 15400  			}
 15401  			var msglen int
 15402  			for shift := uint(0); ; shift += 7 {
 15403  				if shift >= 64 {
 15404  					return ErrIntOverflow
 15405  				}
 15406  				if iNdEx >= l {
 15407  					return io.ErrUnexpectedEOF
 15408  				}
 15409  				b := dAtA[iNdEx]
 15410  				iNdEx++
 15411  				msglen |= int(b&0x7F) << shift
 15412  				if b < 0x80 {
 15413  					break
 15414  				}
 15415  			}
 15416  			if msglen < 0 {
 15417  				return ErrInvalidLength
 15418  			}
 15419  			postIndex := iNdEx + msglen
 15420  			if postIndex < 0 {
 15421  				return ErrInvalidLength
 15422  			}
 15423  			if postIndex > l {
 15424  				return io.ErrUnexpectedEOF
 15425  			}
 15426  			if m.Output == nil {
 15427  				m.Output = &query.QueryResult{}
 15428  			}
 15429  			if err := m.Output.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 15430  				return err
 15431  			}
 15432  			iNdEx = postIndex
 15433  		case 3:
 15434  			if wireType != 2 {
 15435  				return fmt.Errorf("proto: wrong wireType = %d for field VdiffUuid", wireType)
 15436  			}
 15437  			var stringLen uint64
 15438  			for shift := uint(0); ; shift += 7 {
 15439  				if shift >= 64 {
 15440  					return ErrIntOverflow
 15441  				}
 15442  				if iNdEx >= l {
 15443  					return io.ErrUnexpectedEOF
 15444  				}
 15445  				b := dAtA[iNdEx]
 15446  				iNdEx++
 15447  				stringLen |= uint64(b&0x7F) << shift
 15448  				if b < 0x80 {
 15449  					break
 15450  				}
 15451  			}
 15452  			intStringLen := int(stringLen)
 15453  			if intStringLen < 0 {
 15454  				return ErrInvalidLength
 15455  			}
 15456  			postIndex := iNdEx + intStringLen
 15457  			if postIndex < 0 {
 15458  				return ErrInvalidLength
 15459  			}
 15460  			if postIndex > l {
 15461  				return io.ErrUnexpectedEOF
 15462  			}
 15463  			m.VdiffUuid = string(dAtA[iNdEx:postIndex])
 15464  			iNdEx = postIndex
 15465  		default:
 15466  			iNdEx = preIndex
 15467  			skippy, err := skip(dAtA[iNdEx:])
 15468  			if err != nil {
 15469  				return err
 15470  			}
 15471  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15472  				return ErrInvalidLength
 15473  			}
 15474  			if (iNdEx + skippy) > l {
 15475  				return io.ErrUnexpectedEOF
 15476  			}
 15477  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15478  			iNdEx += skippy
 15479  		}
 15480  	}
 15481  
 15482  	if iNdEx > l {
 15483  		return io.ErrUnexpectedEOF
 15484  	}
 15485  	return nil
 15486  }
 15487  func (m *VDiffPickerOptions) UnmarshalVT(dAtA []byte) error {
 15488  	l := len(dAtA)
 15489  	iNdEx := 0
 15490  	for iNdEx < l {
 15491  		preIndex := iNdEx
 15492  		var wire uint64
 15493  		for shift := uint(0); ; shift += 7 {
 15494  			if shift >= 64 {
 15495  				return ErrIntOverflow
 15496  			}
 15497  			if iNdEx >= l {
 15498  				return io.ErrUnexpectedEOF
 15499  			}
 15500  			b := dAtA[iNdEx]
 15501  			iNdEx++
 15502  			wire |= uint64(b&0x7F) << shift
 15503  			if b < 0x80 {
 15504  				break
 15505  			}
 15506  		}
 15507  		fieldNum := int32(wire >> 3)
 15508  		wireType := int(wire & 0x7)
 15509  		if wireType == 4 {
 15510  			return fmt.Errorf("proto: VDiffPickerOptions: wiretype end group for non-group")
 15511  		}
 15512  		if fieldNum <= 0 {
 15513  			return fmt.Errorf("proto: VDiffPickerOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 15514  		}
 15515  		switch fieldNum {
 15516  		case 1:
 15517  			if wireType != 2 {
 15518  				return fmt.Errorf("proto: wrong wireType = %d for field TabletTypes", wireType)
 15519  			}
 15520  			var stringLen uint64
 15521  			for shift := uint(0); ; shift += 7 {
 15522  				if shift >= 64 {
 15523  					return ErrIntOverflow
 15524  				}
 15525  				if iNdEx >= l {
 15526  					return io.ErrUnexpectedEOF
 15527  				}
 15528  				b := dAtA[iNdEx]
 15529  				iNdEx++
 15530  				stringLen |= uint64(b&0x7F) << shift
 15531  				if b < 0x80 {
 15532  					break
 15533  				}
 15534  			}
 15535  			intStringLen := int(stringLen)
 15536  			if intStringLen < 0 {
 15537  				return ErrInvalidLength
 15538  			}
 15539  			postIndex := iNdEx + intStringLen
 15540  			if postIndex < 0 {
 15541  				return ErrInvalidLength
 15542  			}
 15543  			if postIndex > l {
 15544  				return io.ErrUnexpectedEOF
 15545  			}
 15546  			m.TabletTypes = string(dAtA[iNdEx:postIndex])
 15547  			iNdEx = postIndex
 15548  		case 2:
 15549  			if wireType != 2 {
 15550  				return fmt.Errorf("proto: wrong wireType = %d for field SourceCell", wireType)
 15551  			}
 15552  			var stringLen uint64
 15553  			for shift := uint(0); ; shift += 7 {
 15554  				if shift >= 64 {
 15555  					return ErrIntOverflow
 15556  				}
 15557  				if iNdEx >= l {
 15558  					return io.ErrUnexpectedEOF
 15559  				}
 15560  				b := dAtA[iNdEx]
 15561  				iNdEx++
 15562  				stringLen |= uint64(b&0x7F) << shift
 15563  				if b < 0x80 {
 15564  					break
 15565  				}
 15566  			}
 15567  			intStringLen := int(stringLen)
 15568  			if intStringLen < 0 {
 15569  				return ErrInvalidLength
 15570  			}
 15571  			postIndex := iNdEx + intStringLen
 15572  			if postIndex < 0 {
 15573  				return ErrInvalidLength
 15574  			}
 15575  			if postIndex > l {
 15576  				return io.ErrUnexpectedEOF
 15577  			}
 15578  			m.SourceCell = string(dAtA[iNdEx:postIndex])
 15579  			iNdEx = postIndex
 15580  		case 3:
 15581  			if wireType != 2 {
 15582  				return fmt.Errorf("proto: wrong wireType = %d for field TargetCell", wireType)
 15583  			}
 15584  			var stringLen uint64
 15585  			for shift := uint(0); ; shift += 7 {
 15586  				if shift >= 64 {
 15587  					return ErrIntOverflow
 15588  				}
 15589  				if iNdEx >= l {
 15590  					return io.ErrUnexpectedEOF
 15591  				}
 15592  				b := dAtA[iNdEx]
 15593  				iNdEx++
 15594  				stringLen |= uint64(b&0x7F) << shift
 15595  				if b < 0x80 {
 15596  					break
 15597  				}
 15598  			}
 15599  			intStringLen := int(stringLen)
 15600  			if intStringLen < 0 {
 15601  				return ErrInvalidLength
 15602  			}
 15603  			postIndex := iNdEx + intStringLen
 15604  			if postIndex < 0 {
 15605  				return ErrInvalidLength
 15606  			}
 15607  			if postIndex > l {
 15608  				return io.ErrUnexpectedEOF
 15609  			}
 15610  			m.TargetCell = string(dAtA[iNdEx:postIndex])
 15611  			iNdEx = postIndex
 15612  		default:
 15613  			iNdEx = preIndex
 15614  			skippy, err := skip(dAtA[iNdEx:])
 15615  			if err != nil {
 15616  				return err
 15617  			}
 15618  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15619  				return ErrInvalidLength
 15620  			}
 15621  			if (iNdEx + skippy) > l {
 15622  				return io.ErrUnexpectedEOF
 15623  			}
 15624  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15625  			iNdEx += skippy
 15626  		}
 15627  	}
 15628  
 15629  	if iNdEx > l {
 15630  		return io.ErrUnexpectedEOF
 15631  	}
 15632  	return nil
 15633  }
 15634  func (m *VDiffReportOptions) UnmarshalVT(dAtA []byte) error {
 15635  	l := len(dAtA)
 15636  	iNdEx := 0
 15637  	for iNdEx < l {
 15638  		preIndex := iNdEx
 15639  		var wire uint64
 15640  		for shift := uint(0); ; shift += 7 {
 15641  			if shift >= 64 {
 15642  				return ErrIntOverflow
 15643  			}
 15644  			if iNdEx >= l {
 15645  				return io.ErrUnexpectedEOF
 15646  			}
 15647  			b := dAtA[iNdEx]
 15648  			iNdEx++
 15649  			wire |= uint64(b&0x7F) << shift
 15650  			if b < 0x80 {
 15651  				break
 15652  			}
 15653  		}
 15654  		fieldNum := int32(wire >> 3)
 15655  		wireType := int(wire & 0x7)
 15656  		if wireType == 4 {
 15657  			return fmt.Errorf("proto: VDiffReportOptions: wiretype end group for non-group")
 15658  		}
 15659  		if fieldNum <= 0 {
 15660  			return fmt.Errorf("proto: VDiffReportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 15661  		}
 15662  		switch fieldNum {
 15663  		case 1:
 15664  			if wireType != 0 {
 15665  				return fmt.Errorf("proto: wrong wireType = %d for field OnlyPks", wireType)
 15666  			}
 15667  			var v int
 15668  			for shift := uint(0); ; shift += 7 {
 15669  				if shift >= 64 {
 15670  					return ErrIntOverflow
 15671  				}
 15672  				if iNdEx >= l {
 15673  					return io.ErrUnexpectedEOF
 15674  				}
 15675  				b := dAtA[iNdEx]
 15676  				iNdEx++
 15677  				v |= int(b&0x7F) << shift
 15678  				if b < 0x80 {
 15679  					break
 15680  				}
 15681  			}
 15682  			m.OnlyPks = bool(v != 0)
 15683  		case 2:
 15684  			if wireType != 0 {
 15685  				return fmt.Errorf("proto: wrong wireType = %d for field DebugQuery", wireType)
 15686  			}
 15687  			var v int
 15688  			for shift := uint(0); ; shift += 7 {
 15689  				if shift >= 64 {
 15690  					return ErrIntOverflow
 15691  				}
 15692  				if iNdEx >= l {
 15693  					return io.ErrUnexpectedEOF
 15694  				}
 15695  				b := dAtA[iNdEx]
 15696  				iNdEx++
 15697  				v |= int(b&0x7F) << shift
 15698  				if b < 0x80 {
 15699  					break
 15700  				}
 15701  			}
 15702  			m.DebugQuery = bool(v != 0)
 15703  		case 3:
 15704  			if wireType != 2 {
 15705  				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
 15706  			}
 15707  			var stringLen uint64
 15708  			for shift := uint(0); ; shift += 7 {
 15709  				if shift >= 64 {
 15710  					return ErrIntOverflow
 15711  				}
 15712  				if iNdEx >= l {
 15713  					return io.ErrUnexpectedEOF
 15714  				}
 15715  				b := dAtA[iNdEx]
 15716  				iNdEx++
 15717  				stringLen |= uint64(b&0x7F) << shift
 15718  				if b < 0x80 {
 15719  					break
 15720  				}
 15721  			}
 15722  			intStringLen := int(stringLen)
 15723  			if intStringLen < 0 {
 15724  				return ErrInvalidLength
 15725  			}
 15726  			postIndex := iNdEx + intStringLen
 15727  			if postIndex < 0 {
 15728  				return ErrInvalidLength
 15729  			}
 15730  			if postIndex > l {
 15731  				return io.ErrUnexpectedEOF
 15732  			}
 15733  			m.Format = string(dAtA[iNdEx:postIndex])
 15734  			iNdEx = postIndex
 15735  		default:
 15736  			iNdEx = preIndex
 15737  			skippy, err := skip(dAtA[iNdEx:])
 15738  			if err != nil {
 15739  				return err
 15740  			}
 15741  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15742  				return ErrInvalidLength
 15743  			}
 15744  			if (iNdEx + skippy) > l {
 15745  				return io.ErrUnexpectedEOF
 15746  			}
 15747  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15748  			iNdEx += skippy
 15749  		}
 15750  	}
 15751  
 15752  	if iNdEx > l {
 15753  		return io.ErrUnexpectedEOF
 15754  	}
 15755  	return nil
 15756  }
 15757  func (m *VDiffCoreOptions) UnmarshalVT(dAtA []byte) error {
 15758  	l := len(dAtA)
 15759  	iNdEx := 0
 15760  	for iNdEx < l {
 15761  		preIndex := iNdEx
 15762  		var wire uint64
 15763  		for shift := uint(0); ; shift += 7 {
 15764  			if shift >= 64 {
 15765  				return ErrIntOverflow
 15766  			}
 15767  			if iNdEx >= l {
 15768  				return io.ErrUnexpectedEOF
 15769  			}
 15770  			b := dAtA[iNdEx]
 15771  			iNdEx++
 15772  			wire |= uint64(b&0x7F) << shift
 15773  			if b < 0x80 {
 15774  				break
 15775  			}
 15776  		}
 15777  		fieldNum := int32(wire >> 3)
 15778  		wireType := int(wire & 0x7)
 15779  		if wireType == 4 {
 15780  			return fmt.Errorf("proto: VDiffCoreOptions: wiretype end group for non-group")
 15781  		}
 15782  		if fieldNum <= 0 {
 15783  			return fmt.Errorf("proto: VDiffCoreOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 15784  		}
 15785  		switch fieldNum {
 15786  		case 1:
 15787  			if wireType != 2 {
 15788  				return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType)
 15789  			}
 15790  			var stringLen uint64
 15791  			for shift := uint(0); ; shift += 7 {
 15792  				if shift >= 64 {
 15793  					return ErrIntOverflow
 15794  				}
 15795  				if iNdEx >= l {
 15796  					return io.ErrUnexpectedEOF
 15797  				}
 15798  				b := dAtA[iNdEx]
 15799  				iNdEx++
 15800  				stringLen |= uint64(b&0x7F) << shift
 15801  				if b < 0x80 {
 15802  					break
 15803  				}
 15804  			}
 15805  			intStringLen := int(stringLen)
 15806  			if intStringLen < 0 {
 15807  				return ErrInvalidLength
 15808  			}
 15809  			postIndex := iNdEx + intStringLen
 15810  			if postIndex < 0 {
 15811  				return ErrInvalidLength
 15812  			}
 15813  			if postIndex > l {
 15814  				return io.ErrUnexpectedEOF
 15815  			}
 15816  			m.Tables = string(dAtA[iNdEx:postIndex])
 15817  			iNdEx = postIndex
 15818  		case 2:
 15819  			if wireType != 0 {
 15820  				return fmt.Errorf("proto: wrong wireType = %d for field AutoRetry", wireType)
 15821  			}
 15822  			var v int
 15823  			for shift := uint(0); ; shift += 7 {
 15824  				if shift >= 64 {
 15825  					return ErrIntOverflow
 15826  				}
 15827  				if iNdEx >= l {
 15828  					return io.ErrUnexpectedEOF
 15829  				}
 15830  				b := dAtA[iNdEx]
 15831  				iNdEx++
 15832  				v |= int(b&0x7F) << shift
 15833  				if b < 0x80 {
 15834  					break
 15835  				}
 15836  			}
 15837  			m.AutoRetry = bool(v != 0)
 15838  		case 3:
 15839  			if wireType != 0 {
 15840  				return fmt.Errorf("proto: wrong wireType = %d for field MaxRows", wireType)
 15841  			}
 15842  			m.MaxRows = 0
 15843  			for shift := uint(0); ; shift += 7 {
 15844  				if shift >= 64 {
 15845  					return ErrIntOverflow
 15846  				}
 15847  				if iNdEx >= l {
 15848  					return io.ErrUnexpectedEOF
 15849  				}
 15850  				b := dAtA[iNdEx]
 15851  				iNdEx++
 15852  				m.MaxRows |= int64(b&0x7F) << shift
 15853  				if b < 0x80 {
 15854  					break
 15855  				}
 15856  			}
 15857  		case 4:
 15858  			if wireType != 0 {
 15859  				return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType)
 15860  			}
 15861  			var v int
 15862  			for shift := uint(0); ; shift += 7 {
 15863  				if shift >= 64 {
 15864  					return ErrIntOverflow
 15865  				}
 15866  				if iNdEx >= l {
 15867  					return io.ErrUnexpectedEOF
 15868  				}
 15869  				b := dAtA[iNdEx]
 15870  				iNdEx++
 15871  				v |= int(b&0x7F) << shift
 15872  				if b < 0x80 {
 15873  					break
 15874  				}
 15875  			}
 15876  			m.Checksum = bool(v != 0)
 15877  		case 5:
 15878  			if wireType != 0 {
 15879  				return fmt.Errorf("proto: wrong wireType = %d for field SamplePct", wireType)
 15880  			}
 15881  			m.SamplePct = 0
 15882  			for shift := uint(0); ; shift += 7 {
 15883  				if shift >= 64 {
 15884  					return ErrIntOverflow
 15885  				}
 15886  				if iNdEx >= l {
 15887  					return io.ErrUnexpectedEOF
 15888  				}
 15889  				b := dAtA[iNdEx]
 15890  				iNdEx++
 15891  				m.SamplePct |= int64(b&0x7F) << shift
 15892  				if b < 0x80 {
 15893  					break
 15894  				}
 15895  			}
 15896  		case 6:
 15897  			if wireType != 0 {
 15898  				return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
 15899  			}
 15900  			m.TimeoutSeconds = 0
 15901  			for shift := uint(0); ; shift += 7 {
 15902  				if shift >= 64 {
 15903  					return ErrIntOverflow
 15904  				}
 15905  				if iNdEx >= l {
 15906  					return io.ErrUnexpectedEOF
 15907  				}
 15908  				b := dAtA[iNdEx]
 15909  				iNdEx++
 15910  				m.TimeoutSeconds |= int64(b&0x7F) << shift
 15911  				if b < 0x80 {
 15912  					break
 15913  				}
 15914  			}
 15915  		case 7:
 15916  			if wireType != 0 {
 15917  				return fmt.Errorf("proto: wrong wireType = %d for field MaxExtraRowsToCompare", wireType)
 15918  			}
 15919  			m.MaxExtraRowsToCompare = 0
 15920  			for shift := uint(0); ; shift += 7 {
 15921  				if shift >= 64 {
 15922  					return ErrIntOverflow
 15923  				}
 15924  				if iNdEx >= l {
 15925  					return io.ErrUnexpectedEOF
 15926  				}
 15927  				b := dAtA[iNdEx]
 15928  				iNdEx++
 15929  				m.MaxExtraRowsToCompare |= int64(b&0x7F) << shift
 15930  				if b < 0x80 {
 15931  					break
 15932  				}
 15933  			}
 15934  		default:
 15935  			iNdEx = preIndex
 15936  			skippy, err := skip(dAtA[iNdEx:])
 15937  			if err != nil {
 15938  				return err
 15939  			}
 15940  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 15941  				return ErrInvalidLength
 15942  			}
 15943  			if (iNdEx + skippy) > l {
 15944  				return io.ErrUnexpectedEOF
 15945  			}
 15946  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 15947  			iNdEx += skippy
 15948  		}
 15949  	}
 15950  
 15951  	if iNdEx > l {
 15952  		return io.ErrUnexpectedEOF
 15953  	}
 15954  	return nil
 15955  }
 15956  func (m *VDiffOptions) UnmarshalVT(dAtA []byte) error {
 15957  	l := len(dAtA)
 15958  	iNdEx := 0
 15959  	for iNdEx < l {
 15960  		preIndex := iNdEx
 15961  		var wire uint64
 15962  		for shift := uint(0); ; shift += 7 {
 15963  			if shift >= 64 {
 15964  				return ErrIntOverflow
 15965  			}
 15966  			if iNdEx >= l {
 15967  				return io.ErrUnexpectedEOF
 15968  			}
 15969  			b := dAtA[iNdEx]
 15970  			iNdEx++
 15971  			wire |= uint64(b&0x7F) << shift
 15972  			if b < 0x80 {
 15973  				break
 15974  			}
 15975  		}
 15976  		fieldNum := int32(wire >> 3)
 15977  		wireType := int(wire & 0x7)
 15978  		if wireType == 4 {
 15979  			return fmt.Errorf("proto: VDiffOptions: wiretype end group for non-group")
 15980  		}
 15981  		if fieldNum <= 0 {
 15982  			return fmt.Errorf("proto: VDiffOptions: illegal tag %d (wire type %d)", fieldNum, wire)
 15983  		}
 15984  		switch fieldNum {
 15985  		case 1:
 15986  			if wireType != 2 {
 15987  				return fmt.Errorf("proto: wrong wireType = %d for field PickerOptions", wireType)
 15988  			}
 15989  			var msglen int
 15990  			for shift := uint(0); ; shift += 7 {
 15991  				if shift >= 64 {
 15992  					return ErrIntOverflow
 15993  				}
 15994  				if iNdEx >= l {
 15995  					return io.ErrUnexpectedEOF
 15996  				}
 15997  				b := dAtA[iNdEx]
 15998  				iNdEx++
 15999  				msglen |= int(b&0x7F) << shift
 16000  				if b < 0x80 {
 16001  					break
 16002  				}
 16003  			}
 16004  			if msglen < 0 {
 16005  				return ErrInvalidLength
 16006  			}
 16007  			postIndex := iNdEx + msglen
 16008  			if postIndex < 0 {
 16009  				return ErrInvalidLength
 16010  			}
 16011  			if postIndex > l {
 16012  				return io.ErrUnexpectedEOF
 16013  			}
 16014  			if m.PickerOptions == nil {
 16015  				m.PickerOptions = &VDiffPickerOptions{}
 16016  			}
 16017  			if err := m.PickerOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16018  				return err
 16019  			}
 16020  			iNdEx = postIndex
 16021  		case 2:
 16022  			if wireType != 2 {
 16023  				return fmt.Errorf("proto: wrong wireType = %d for field CoreOptions", wireType)
 16024  			}
 16025  			var msglen int
 16026  			for shift := uint(0); ; shift += 7 {
 16027  				if shift >= 64 {
 16028  					return ErrIntOverflow
 16029  				}
 16030  				if iNdEx >= l {
 16031  					return io.ErrUnexpectedEOF
 16032  				}
 16033  				b := dAtA[iNdEx]
 16034  				iNdEx++
 16035  				msglen |= int(b&0x7F) << shift
 16036  				if b < 0x80 {
 16037  					break
 16038  				}
 16039  			}
 16040  			if msglen < 0 {
 16041  				return ErrInvalidLength
 16042  			}
 16043  			postIndex := iNdEx + msglen
 16044  			if postIndex < 0 {
 16045  				return ErrInvalidLength
 16046  			}
 16047  			if postIndex > l {
 16048  				return io.ErrUnexpectedEOF
 16049  			}
 16050  			if m.CoreOptions == nil {
 16051  				m.CoreOptions = &VDiffCoreOptions{}
 16052  			}
 16053  			if err := m.CoreOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16054  				return err
 16055  			}
 16056  			iNdEx = postIndex
 16057  		case 3:
 16058  			if wireType != 2 {
 16059  				return fmt.Errorf("proto: wrong wireType = %d for field ReportOptions", wireType)
 16060  			}
 16061  			var msglen int
 16062  			for shift := uint(0); ; shift += 7 {
 16063  				if shift >= 64 {
 16064  					return ErrIntOverflow
 16065  				}
 16066  				if iNdEx >= l {
 16067  					return io.ErrUnexpectedEOF
 16068  				}
 16069  				b := dAtA[iNdEx]
 16070  				iNdEx++
 16071  				msglen |= int(b&0x7F) << shift
 16072  				if b < 0x80 {
 16073  					break
 16074  				}
 16075  			}
 16076  			if msglen < 0 {
 16077  				return ErrInvalidLength
 16078  			}
 16079  			postIndex := iNdEx + msglen
 16080  			if postIndex < 0 {
 16081  				return ErrInvalidLength
 16082  			}
 16083  			if postIndex > l {
 16084  				return io.ErrUnexpectedEOF
 16085  			}
 16086  			if m.ReportOptions == nil {
 16087  				m.ReportOptions = &VDiffReportOptions{}
 16088  			}
 16089  			if err := m.ReportOptions.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 16090  				return err
 16091  			}
 16092  			iNdEx = postIndex
 16093  		default:
 16094  			iNdEx = preIndex
 16095  			skippy, err := skip(dAtA[iNdEx:])
 16096  			if err != nil {
 16097  				return err
 16098  			}
 16099  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 16100  				return ErrInvalidLength
 16101  			}
 16102  			if (iNdEx + skippy) > l {
 16103  				return io.ErrUnexpectedEOF
 16104  			}
 16105  			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
 16106  			iNdEx += skippy
 16107  		}
 16108  	}
 16109  
 16110  	if iNdEx > l {
 16111  		return io.ErrUnexpectedEOF
 16112  	}
 16113  	return nil
 16114  }
 16115  
 16116  func skip(dAtA []byte) (n int, err error) {
 16117  	l := len(dAtA)
 16118  	iNdEx := 0
 16119  	depth := 0
 16120  	for iNdEx < l {
 16121  		var wire uint64
 16122  		for shift := uint(0); ; shift += 7 {
 16123  			if shift >= 64 {
 16124  				return 0, ErrIntOverflow
 16125  			}
 16126  			if iNdEx >= l {
 16127  				return 0, io.ErrUnexpectedEOF
 16128  			}
 16129  			b := dAtA[iNdEx]
 16130  			iNdEx++
 16131  			wire |= (uint64(b) & 0x7F) << shift
 16132  			if b < 0x80 {
 16133  				break
 16134  			}
 16135  		}
 16136  		wireType := int(wire & 0x7)
 16137  		switch wireType {
 16138  		case 0:
 16139  			for shift := uint(0); ; shift += 7 {
 16140  				if shift >= 64 {
 16141  					return 0, ErrIntOverflow
 16142  				}
 16143  				if iNdEx >= l {
 16144  					return 0, io.ErrUnexpectedEOF
 16145  				}
 16146  				iNdEx++
 16147  				if dAtA[iNdEx-1] < 0x80 {
 16148  					break
 16149  				}
 16150  			}
 16151  		case 1:
 16152  			iNdEx += 8
 16153  		case 2:
 16154  			var length int
 16155  			for shift := uint(0); ; shift += 7 {
 16156  				if shift >= 64 {
 16157  					return 0, ErrIntOverflow
 16158  				}
 16159  				if iNdEx >= l {
 16160  					return 0, io.ErrUnexpectedEOF
 16161  				}
 16162  				b := dAtA[iNdEx]
 16163  				iNdEx++
 16164  				length |= (int(b) & 0x7F) << shift
 16165  				if b < 0x80 {
 16166  					break
 16167  				}
 16168  			}
 16169  			if length < 0 {
 16170  				return 0, ErrInvalidLength
 16171  			}
 16172  			iNdEx += length
 16173  		case 3:
 16174  			depth++
 16175  		case 4:
 16176  			if depth == 0 {
 16177  				return 0, ErrUnexpectedEndOfGroup
 16178  			}
 16179  			depth--
 16180  		case 5:
 16181  			iNdEx += 4
 16182  		default:
 16183  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 16184  		}
 16185  		if iNdEx < 0 {
 16186  			return 0, ErrInvalidLength
 16187  		}
 16188  		if depth == 0 {
 16189  			return iNdEx, nil
 16190  		}
 16191  	}
 16192  	return 0, io.ErrUnexpectedEOF
 16193  }
 16194  
 16195  var (
 16196  	ErrInvalidLength        = fmt.Errorf("proto: negative length found during unmarshaling")
 16197  	ErrIntOverflow          = fmt.Errorf("proto: integer overflow")
 16198  	ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group")
 16199  )