github.com/matrixorigin/matrixone@v1.2.0/pkg/pb/lock/lock.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lock.proto

package lock

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	timestamp "github.com/matrixorigin/matrixone/pkg/pb/timestamp"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Granularity row granularity, single row or row range
type Granularity int32

const (
	Granularity_Row   Granularity = 0
	Granularity_Range Granularity = 1
)

var Granularity_name = map[int32]string{
	0: "Row",
	1: "Range",
}

var Granularity_value = map[string]int32{
	"Row":   0,
	"Range": 1,
}

func (x Granularity) String() string {
	return proto.EnumName(Granularity_name, int32(x))
}

func (Granularity) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{0}
}

// LockMode lock mode
type LockMode int32

const (
	LockMode_Exclusive LockMode = 0
	LockMode_Shared    LockMode = 1
)

var LockMode_name = map[int32]string{
	0: "Exclusive",
	1: "Shared",
}

var LockMode_value = map[string]int32{
	"Exclusive": 0,
	"Shared":    1,
}

func (x LockMode) String() string {
	return proto.EnumName(LockMode_name, int32(x))
}

func (LockMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{1}
}

// WaitPolicy wait policy
type WaitPolicy int32

const (
	WaitPolicy_Wait     WaitPolicy = 0
	WaitPolicy_FastFail WaitPolicy = 1
)

var WaitPolicy_name = map[int32]string{
	0: "Wait",
	1: "FastFail",
}

var WaitPolicy_value = map[string]int32{
	"Wait":     0,
	"FastFail": 1,
}

func (x WaitPolicy) String() string {
	return proto.EnumName(WaitPolicy_name, int32(x))
}

func (WaitPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{2}
}

type Sharding int32

const (
	Sharding_None  Sharding = 0
	Sharding_ByRow Sharding = 1
)

var Sharding_name = map[int32]string{
	0: "None",
	1: "ByRow",
}

var Sharding_value = map[string]int32{
	"None":  0,
	"ByRow": 1,
}

func (x Sharding) String() string {
	return proto.EnumName(Sharding_name, int32(x))
}

func (Sharding) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{3}
}

// Method lock table operations
type Method int32

const (
	// Lock lock rows on remote lock table
	Method_Lock Method = 0
	// Write unlock rows from remote lock table
	Method_Unlock Method = 1
	// GetTxnLock get lock data on a special lock
	Method_GetTxnLock Method = 2
	// GetWaitingList get waiting txns on a special lock
	Method_GetWaitingList Method = 3
	// KeepRemoteLock keep remote lock on remote lock service
	Method_KeepRemoteLock Method = 4
	// GetBind get or create lock table bind from lock table allocator
	Method_GetBind Method = 5
	// KeepLockTableBind keep the lock table bind on lock table allocator
	Method_KeepLockTableBind Method = 6
	// ForwardLock forward lock request to another service
	Method_ForwardLock Method = 7
	// ForwardUnlock forward unlock request to another service
	Method_ForwardUnlock Method = 8
	// ValidateService validate if lock service alive
	Method_ValidateService Method = 9
	// CannotCommit for orphaned transactions that are found, the lock is released
	// immediately, and you need to mark these transactions as not being able to be
	// committed in the TN
	Method_CannotCommit Method = 10
	// GetActiveTxn used to get the active txn on the lock service
	Method_GetActiveTxn Method = 11
	// SetRestartService set restart lock service
	Method_SetRestartService Method = 12
	// RemainTxnInService get remain txn in lock service
	Method_RemainTxnInService Method = 13
	// canRestartService judge if can restart lock service
	Method_CanRestartService Method = 14
)

var Method_name = map[int32]string{
	0:  "Lock",
	1:  "Unlock",
	2:  "GetTxnLock",
	3:  "GetWaitingList",
	4:  "KeepRemoteLock",
	5:  "GetBind",
	6:  "KeepLockTableBind",
	7:  "ForwardLock",
	8:  "ForwardUnlock",
	9:  "ValidateService",
	10: "CannotCommit",
	11: "GetActiveTxn",
	12: "SetRestartService",
	13: "RemainTxnInService",
	14: "CanRestartService",
}

var Method_value = map[string]int32{
	"Lock":               0,
	"Unlock":             1,
	"GetTxnLock":         2,
	"GetWaitingList":     3,
	"KeepRemoteLock":     4,
	"GetBind":            5,
	"KeepLockTableBind":  6,
	"ForwardLock":        7,
	"ForwardUnlock":      8,
	"ValidateService":    9,
	"CannotCommit":       10,
	"GetActiveTxn":       11,
	"SetRestartService":  12,
	"RemainTxnInService": 13,
	"CanRestartService":  14,
}

func (x Method) String() string {
	return proto.EnumName(Method_name, int32(x))
}

func (Method) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{4}
}

type Status int32

const (
	Status_ServiceLockEnable  Status = 0
	Status_ServiceLockWaiting Status = 1
	Status_ServiceUnLockSucc  Status = 2
	Status_ServiceCanRestart  Status = 3
)

var Status_name = map[int32]string{
	0: "ServiceLockEnable",
	1: "ServiceLockWaiting",
	2: "ServiceUnLockSucc",
	3: "ServiceCanRestart",
}

var Status_value = map[string]int32{
	"ServiceLockEnable":  0,
	"ServiceLockWaiting": 1,
	"ServiceUnLockSucc":  2,
	"ServiceCanRestart":  3,
}

func (x Status) String() string {
	return proto.EnumName(Status_name, int32(x))
}

func (Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{5}
}

// LockOptions lock options
type LockOptions struct {
	Granularity          Granularity         `protobuf:"varint,1,opt,name=Granularity,proto3,enum=lock.Granularity" json:"Granularity,omitempty"`
	Mode                 LockMode            `protobuf:"varint,2,opt,name=Mode,proto3,enum=lock.LockMode" json:"Mode,omitempty"`
	Policy               WaitPolicy          `protobuf:"varint,3,opt,name=Policy,proto3,enum=lock.WaitPolicy" json:"Policy,omitempty"`
	ForwardTo            string              `protobuf:"bytes,4,opt,name=ForwardTo,proto3" json:"ForwardTo,omitempty"`
	TableDefChanged      bool                `protobuf:"varint,5,opt,name=TableDefChanged,proto3" json:"TableDefChanged,omitempty"`
	RetryWait            int64               `protobuf:"varint,6,opt,name=RetryWait,proto3" json:"RetryWait,omitempty"`
	Group                uint32              `protobuf:"varint,7,opt,name=Group,proto3" json:"Group,omitempty"`
	Sharding             Sharding            `protobuf:"varint,8,opt,name=Sharding,proto3,enum=lock.Sharding" json:"Sharding,omitempty"`
	SnapShotTs           timestamp.Timestamp `protobuf:"bytes,9,opt,name=SnapShotTs,proto3" json:"SnapShotTs"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *LockOptions) Reset()         { *m = LockOptions{} }
func (m *LockOptions) String() string { return proto.CompactTextString(m) }
func (*LockOptions) ProtoMessage()    {}
func (*LockOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{0}
}
func (m *LockOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LockOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LockOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LockOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LockOptions.Merge(m, src)
}
func (m *LockOptions) XXX_Size() int {
	return m.Size()
}
func (m *LockOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_LockOptions.DiscardUnknown(m)
}

var xxx_messageInfo_LockOptions proto.InternalMessageInfo

func (m *LockOptions) GetGranularity() Granularity {
	if m != nil {
		return m.Granularity
	}
	return Granularity_Row
}

func (m *LockOptions) GetMode() LockMode {
	if m != nil {
		return m.Mode
	}
	return LockMode_Exclusive
}

func (m *LockOptions) GetPolicy() WaitPolicy {
	if m != nil {
		return m.Policy
	}
	return WaitPolicy_Wait
}

func (m *LockOptions) GetForwardTo() string {
	if m != nil {
		return m.ForwardTo
	}
	return ""
}

func (m *LockOptions) GetTableDefChanged() bool {
	if m != nil {
		return m.TableDefChanged
	}
	return false
}

func (m *LockOptions) GetRetryWait() int64 {
	if m != nil {
		return m.RetryWait
	}
	return 0
}

func (m *LockOptions) GetGroup() uint32 {
	if m != nil {
		return m.Group
	}
	return 0
}

func (m *LockOptions) GetSharding() Sharding {
	if m != nil {
		return m.Sharding
	}
	return Sharding_None
}

func (m *LockOptions) GetSnapShotTs() timestamp.Timestamp {
	if m != nil {
		return m.SnapShotTs
	}
	return timestamp.Timestamp{}
}

// LockTable describes which CN manages a Table's Locks.
type LockTable struct {
	// Table table id
	Table uint64 `protobuf:"varint,1,opt,name=Table,proto3" json:"Table,omitempty"`
	// ServiceID lock service id, a cn node will only run one instance of LockService
	ServiceID string `protobuf:"bytes,2,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	// Version will incr if CN-Table bind changed.
	Version uint64 `protobuf:"varint,3,opt,name=Version,proto3" json:"Version,omitempty"`
	// Valid false if the service is disabled, and no new service bind this table
	Valid                bool     `protobuf:"varint,4,opt,name=Valid,proto3" json:"Valid,omitempty"`
	Group                uint32   `protobuf:"varint,5,opt,name=Group,proto3" json:"Group,omitempty"`
	Sharding             Sharding `protobuf:"varint,6,opt,name=Sharding,proto3,enum=lock.Sharding" json:"Sharding,omitempty"`
	OriginTable          uint64   `protobuf:"varint,7,opt,name=OriginTable,proto3" json:"OriginTable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LockTable) Reset()         { *m = LockTable{} }
func (m *LockTable) String() string { return proto.CompactTextString(m) }
func (*LockTable) ProtoMessage()    {}
func (*LockTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{1}
}
func (m *LockTable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LockTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LockTable.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LockTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LockTable.Merge(m, src)
}
func (m *LockTable) XXX_Size() int {
	return m.Size()
}
func (m *LockTable) XXX_DiscardUnknown() {
	xxx_messageInfo_LockTable.DiscardUnknown(m)
}

var xxx_messageInfo_LockTable proto.InternalMessageInfo

func (m *LockTable) GetTable() uint64 {
	if m != nil {
		return m.Table
	}
	return 0
}

func (m *LockTable) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

func (m *LockTable) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *LockTable) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

func (m *LockTable) GetGroup() uint32 {
	if m != nil {
		return m.Group
	}
	return 0
}

func (m *LockTable) GetSharding() Sharding {
	if m != nil {
		return m.Sharding
	}
	return Sharding_None
}

func (m *LockTable) GetOriginTable() uint64 {
	if m != nil {
		return m.OriginTable
	}
	return 0
}

// Request is used to send a request for a LockTable related operation to another
// service.
type Request struct {
	// RequestID request id
	RequestID uint64 `protobuf:"varint,1,opt,name=RequestID,proto3" json:"RequestID,omitempty"`
	// LockTable lock target table
	LockTable            LockTable                 `protobuf:"bytes,2,opt,name=LockTable,proto3" json:"LockTable"`
	Method               Method                    `protobuf:"varint,3,opt,name=Method,proto3,enum=lock.Method" json:"Method,omitempty"`
	Lock                 LockRequest               `protobuf:"bytes,4,opt,name=Lock,proto3" json:"Lock"`
	Unlock               UnlockRequest             `protobuf:"bytes,5,opt,name=Unlock,proto3" json:"Unlock"`
	GetTxnLock           GetTxnLockRequest         `protobuf:"bytes,6,opt,name=GetTxnLock,proto3" json:"GetTxnLock"`
	GetWaitingList       GetWaitingListRequest     `protobuf:"bytes,7,opt,name=GetWaitingList,proto3" json:"GetWaitingList"`
	GetBind              GetBindRequest            `protobuf:"bytes,8,opt,name=GetBind,proto3" json:"GetBind"`
	KeepLockTableBind    KeepLockTableBindRequest  `protobuf:"bytes,9,opt,name=KeepLockTableBind,proto3" json:"KeepLockTableBind"`
	KeepRemoteLock       KeepRemoteLockRequest     `protobuf:"bytes,10,opt,name=KeepRemoteLock,proto3" json:"KeepRemoteLock"`
	ValidateService      ValidateServiceRequest    `protobuf:"bytes,11,opt,name=ValidateService,proto3" json:"ValidateService"`
	CannotCommit         CannotCommitRequest       `protobuf:"bytes,12,opt,name=CannotCommit,proto3" json:"CannotCommit"`
	GetActiveTxn         GetActiveTxnRequest       `protobuf:"bytes,13,opt,name=GetActiveTxn,proto3" json:"GetActiveTxn"`
	SetRestartService    SetRestartServiceRequest  `protobuf:"bytes,14,opt,name=SetRestartService,proto3" json:"SetRestartService"`
	CanRestartService    CanRestartServiceRequest  `protobuf:"bytes,15,opt,name=CanRestartService,proto3" json:"CanRestartService"`
	RemainTxnInService   RemainTxnInServiceRequest `protobuf:"bytes,16,opt,name=RemainTxnInService,proto3" json:"RemainTxnInService"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *Request) Reset()         { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage()    {}
func (*Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{2}
}
func (m *Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
	return m.Size()
}
func (m *Request) XXX_DiscardUnknown() {
	xxx_messageInfo_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Request proto.InternalMessageInfo

func (m *Request) GetRequestID() uint64 {
	if m != nil {
		return m.RequestID
	}
	return 0
}

func (m *Request) GetLockTable() LockTable {
	if m != nil {
		return m.LockTable
	}
	return LockTable{}
}

func (m *Request) GetMethod() Method {
	if m != nil {
		return m.Method
	}
	return Method_Lock
}

func (m *Request) GetLock() LockRequest {
	if m != nil {
		return m.Lock
	}
	return LockRequest{}
}

func (m *Request) GetUnlock() UnlockRequest {
	if m != nil {
		return m.Unlock
	}
	return UnlockRequest{}
}

func (m *Request) GetGetTxnLock() GetTxnLockRequest {
	if m != nil {
		return m.GetTxnLock
	}
	return GetTxnLockRequest{}
}

func (m *Request) GetGetWaitingList() GetWaitingListRequest {
	if m != nil {
		return m.GetWaitingList
	}
	return GetWaitingListRequest{}
}

func (m *Request) GetGetBind() GetBindRequest {
	if m != nil {
		return m.GetBind
	}
	return GetBindRequest{}
}

func (m *Request) GetKeepLockTableBind() KeepLockTableBindRequest {
	if m != nil {
		return m.KeepLockTableBind
	}
	return KeepLockTableBindRequest{}
}

func (m *Request) GetKeepRemoteLock() KeepRemoteLockRequest {
	if m != nil {
		return m.KeepRemoteLock
	}
	return KeepRemoteLockRequest{}
}

func (m *Request) GetValidateService() ValidateServiceRequest {
	if m != nil {
		return m.ValidateService
	}
	return ValidateServiceRequest{}
}

func (m *Request) GetCannotCommit() CannotCommitRequest {
	if m != nil {
		return m.CannotCommit
	}
	return CannotCommitRequest{}
}

func (m *Request) GetGetActiveTxn() GetActiveTxnRequest {
	if m != nil {
		return m.GetActiveTxn
	}
	return GetActiveTxnRequest{}
}

func (m *Request) GetSetRestartService() SetRestartServiceRequest {
	if m != nil {
		return m.SetRestartService
	}
	return SetRestartServiceRequest{}
}

func (m *Request) GetCanRestartService() CanRestartServiceRequest {
	if m != nil {
		return m.CanRestartService
	}
	return CanRestartServiceRequest{}
}

func (m *Request) GetRemainTxnInService() RemainTxnInServiceRequest {
	if m != nil {
		return m.RemainTxnInService
	}
	return RemainTxnInServiceRequest{}
}

// Response response
type Response struct {
	// RequestID corresponding request id
	RequestID uint64 `protobuf:"varint,1,opt,name=RequestID,proto3" json:"RequestID,omitempty"`
	Method    Method `protobuf:"varint,2,opt,name=Method,proto3,enum=lock.Method" json:"Method,omitempty"`
	// Error we use this field to send moerr from service to another cn. Set with
	// moerr.MarshalBinary, and use moerr.UnmarshalBinary to restore moerr.
	Error                []byte                     `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
	NewBind              *LockTable                 `protobuf:"bytes,4,opt,name=NewBind,proto3" json:"NewBind,omitempty"`
	Lock                 LockResponse               `protobuf:"bytes,5,opt,name=Lock,proto3" json:"Lock"`
	Unlock               UnlockResponse             `protobuf:"bytes,6,opt,name=Unlock,proto3" json:"Unlock"`
	GetTxnLock           GetTxnLockResponse         `protobuf:"bytes,7,opt,name=GetTxnLock,proto3" json:"GetTxnLock"`
	GetWaitingList       GetWaitingListResponse     `protobuf:"bytes,8,opt,name=GetWaitingList,proto3" json:"GetWaitingList"`
	GetBind              GetBindResponse            `protobuf:"bytes,9,opt,name=GetBind,proto3" json:"GetBind"`
	KeepLockTableBind    KeepLockTableBindResponse  `protobuf:"bytes,10,opt,name=KeepLockTableBind,proto3" json:"KeepLockTableBind"`
	KeepRemoteLock       KeepRemoteLockResponse     `protobuf:"bytes,11,opt,name=KeepRemoteLock,proto3" json:"KeepRemoteLock"`
	ValidateService      ValidateServiceResponse    `protobuf:"bytes,12,opt,name=ValidateService,proto3" json:"ValidateService"`
	CannotCommit         CannotCommitResponse       `protobuf:"bytes,13,opt,name=CannotCommit,proto3" json:"CannotCommit"`
	GetActiveTxn         GetActiveTxnResponse       `protobuf:"bytes,14,opt,name=GetActiveTxn,proto3" json:"GetActiveTxn"`
	SetRestartService    SetRestartServiceResponse  `protobuf:"bytes,15,opt,name=SetRestartService,proto3" json:"SetRestartService"`
	CanRestartService    CanRestartServiceResponse  `protobuf:"bytes,16,opt,name=CanRestartService,proto3" json:"CanRestartService"`
	RemainTxnInService   RemainTxnInServiceResponse `protobuf:"bytes,17,opt,name=RemainTxnInService,proto3" json:"RemainTxnInService"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *Response) Reset()         { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage()    {}
func (*Response) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{3}
}
func (m *Response) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Response.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Response.Merge(m, src)
}
func (m *Response) XXX_Size() int {
	return m.Size()
}
func (m *Response) XXX_DiscardUnknown() {
	xxx_messageInfo_Response.DiscardUnknown(m)
}

var xxx_messageInfo_Response proto.InternalMessageInfo

func (m *Response) GetRequestID() uint64 {
	if m != nil {
		return m.RequestID
	}
	return 0
}

func (m *Response) GetMethod() Method {
	if m != nil {
		return m.Method
	}
	return Method_Lock
}

func (m *Response) GetError() []byte {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *Response) GetNewBind() *LockTable {
	if m != nil {
		return m.NewBind
	}
	return nil
}

func (m *Response) GetLock() LockResponse {
	if m != nil {
		return m.Lock
	}
	return LockResponse{}
}

func (m *Response) GetUnlock() UnlockResponse {
	if m != nil {
		return m.Unlock
	}
	return UnlockResponse{}
}

func (m *Response) GetGetTxnLock() GetTxnLockResponse {
	if m != nil {
		return m.GetTxnLock
	}
	return GetTxnLockResponse{}
}

func (m *Response) GetGetWaitingList() GetWaitingListResponse {
	if m != nil {
		return m.GetWaitingList
	}
	return GetWaitingListResponse{}
}

func (m *Response) GetGetBind() GetBindResponse {
	if m != nil {
		return m.GetBind
	}
	return GetBindResponse{}
}

func (m *Response) GetKeepLockTableBind() KeepLockTableBindResponse {
	if m != nil {
		return m.KeepLockTableBind
	}
	return KeepLockTableBindResponse{}
}

func (m *Response) GetKeepRemoteLock() KeepRemoteLockResponse {
	if m != nil {
		return m.KeepRemoteLock
	}
	return KeepRemoteLockResponse{}
}

func (m *Response) GetValidateService() ValidateServiceResponse {
	if m != nil {
		return m.ValidateService
	}
	return ValidateServiceResponse{}
}

func (m *Response) GetCannotCommit() CannotCommitResponse {
	if m != nil {
		return m.CannotCommit
	}
	return CannotCommitResponse{}
}

func (m *Response) GetGetActiveTxn() GetActiveTxnResponse {
	if m != nil {
		return m.GetActiveTxn
	}
	return GetActiveTxnResponse{}
}

func (m *Response) GetSetRestartService() SetRestartServiceResponse {
	if m != nil {
		return m.SetRestartService
	}
	return SetRestartServiceResponse{}
}

func (m *Response) GetCanRestartService() CanRestartServiceResponse {
	if m != nil {
		return m.CanRestartService
	}
	return CanRestartServiceResponse{}
}

func (m *Response) GetRemainTxnInService() RemainTxnInServiceResponse {
	if m != nil {
		return m.RemainTxnInService
	}
	return RemainTxnInServiceResponse{}
}

// LockRequest lock request
type LockRequest struct {
	TxnID     []byte   `protobuf:"bytes,1,opt,name=TxnID,proto3" json:"TxnID,omitempty"`
	ServiceID string   `protobuf:"bytes,2,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	Rows      [][]byte `protobuf:"bytes,3,rep,name=Rows,proto3" json:"Rows,omitempty"`
	// LockOptions lock options
	Options              LockOptions `protobuf:"bytes,4,opt,name=Options,proto3" json:"Options"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *LockRequest) Reset()         { *m = LockRequest{} }
func (m *LockRequest) String() string { return proto.CompactTextString(m) }
func (*LockRequest) ProtoMessage()    {}
func (*LockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{4}
}
func (m *LockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LockRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LockRequest.Merge(m, src)
}
func (m *LockRequest) XXX_Size() int {
	return m.Size()
}
func (m *LockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LockRequest proto.InternalMessageInfo

func (m *LockRequest) GetTxnID() []byte {
	if m != nil {
		return m.TxnID
	}
	return nil
}

func (m *LockRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

func (m *LockRequest) GetRows() [][]byte {
	if m != nil {
		return m.Rows
	}
	return nil
}

func (m *LockRequest) GetOptions() LockOptions {
	if m != nil {
		return m.Options
	}
	return LockOptions{}
}

// LockResponse lock response
type LockResponse struct {
	Result               Result   `protobuf:"bytes,1,opt,name=Result,proto3" json:"Result"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LockResponse) Reset()         { *m = LockResponse{} }
func (m *LockResponse) String() string { return proto.CompactTextString(m) }
func (*LockResponse) ProtoMessage()    {}
func (*LockResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{5}
}
func (m *LockResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LockResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LockResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LockResponse.Merge(m, src)
}
func (m *LockResponse) XXX_Size() int {
	return m.Size()
}
func (m *LockResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LockResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LockResponse proto.InternalMessageInfo

func (m *LockResponse) GetResult() Result {
	if m != nil {
		return m.Result
	}
	return Result{}
}

// GetTxnLockRequest get a waiting txn list on a special lock
// request, used to dead lock detect
type GetTxnLockRequest struct {
	TxnID                []byte   `protobuf:"bytes,1,opt,name=TxnID,proto3" json:"TxnID,omitempty"`
	Row                  []byte   `protobuf:"bytes,2,opt,name=Row,proto3" json:"Row,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetTxnLockRequest) Reset()         { *m = GetTxnLockRequest{} }
func (m *GetTxnLockRequest) String() string { return proto.CompactTextString(m) }
func (*GetTxnLockRequest) ProtoMessage()    {}
func (*GetTxnLockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{6}
}
func (m *GetTxnLockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTxnLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTxnLockRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTxnLockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTxnLockRequest.Merge(m, src)
}
func (m *GetTxnLockRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetTxnLockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTxnLockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetTxnLockRequest proto.InternalMessageInfo

func (m *GetTxnLockRequest) GetTxnID() []byte {
	if m != nil {
		return m.TxnID
	}
	return nil
}

func (m *GetTxnLockRequest) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

// GetTxnLockResponse get txn Lock response
type GetTxnLockResponse struct {
	Value                int32     `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"`
	WaitingList          []WaitTxn `protobuf:"bytes,2,rep,name=WaitingList,proto3" json:"WaitingList"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GetTxnLockResponse) Reset()         { *m = GetTxnLockResponse{} }
func (m *GetTxnLockResponse) String() string { return proto.CompactTextString(m) }
func (*GetTxnLockResponse) ProtoMessage()    {}
func (*GetTxnLockResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{7}
}
func (m *GetTxnLockResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetTxnLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetTxnLockResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetTxnLockResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetTxnLockResponse.Merge(m, src)
}
func (m *GetTxnLockResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetTxnLockResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetTxnLockResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetTxnLockResponse proto.InternalMessageInfo

func (m *GetTxnLockResponse) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *GetTxnLockResponse) GetWaitingList() []WaitTxn {
	if m != nil {
		return m.WaitingList
	}
	return nil
}

// GetWaitingListRequest get a waiting txn list on a specical txn request. CN -> CN
type GetWaitingListRequest struct {
	Txn                  WaitTxn  `protobuf:"bytes,1,opt,name=Txn,proto3" json:"Txn"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetWaitingListRequest) Reset()         { *m = GetWaitingListRequest{} }
func (m *GetWaitingListRequest) String() string { return proto.CompactTextString(m) }
func (*GetWaitingListRequest) ProtoMessage()    {}
func (*GetWaitingListRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{8}
}
func (m *GetWaitingListRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetWaitingListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetWaitingListRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetWaitingListRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetWaitingListRequest.Merge(m, src)
}
func (m *GetWaitingListRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetWaitingListRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetWaitingListRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetWaitingListRequest proto.InternalMessageInfo

func (m *GetWaitingListRequest) GetTxn() WaitTxn {
	if m != nil {
		return m.Txn
	}
	return WaitTxn{}
}

// GetWaitingListResponse get a waiting txn list on a specical txn response. CN -> CN
type GetWaitingListResponse struct {
	WaitingList          []WaitTxn `protobuf:"bytes,1,rep,name=WaitingList,proto3" json:"WaitingList"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GetWaitingListResponse) Reset()         { *m = GetWaitingListResponse{} }
func (m *GetWaitingListResponse) String() string { return proto.CompactTextString(m) }
func (*GetWaitingListResponse) ProtoMessage()    {}
func (*GetWaitingListResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{9}
}
func (m *GetWaitingListResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetWaitingListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetWaitingListResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetWaitingListResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetWaitingListResponse.Merge(m, src)
}
func (m *GetWaitingListResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetWaitingListResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetWaitingListResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetWaitingListResponse proto.InternalMessageInfo

func (m *GetWaitingListResponse) GetWaitingList() []WaitTxn {
	if m != nil {
		return m.WaitingList
	}
	return nil
}

// WaitTxn wait txn include txn created on
type WaitTxn struct {
	TxnID                []byte   `protobuf:"bytes,1,opt,name=TxnID,proto3" json:"TxnID,omitempty"`
	CreatedOn            string   `protobuf:"bytes,2,opt,name=CreatedOn,proto3" json:"CreatedOn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WaitTxn) Reset()         { *m = WaitTxn{} }
func (m *WaitTxn) String() string { return proto.CompactTextString(m) }
func (*WaitTxn) ProtoMessage()    {}
func (*WaitTxn) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{10}
}
func (m *WaitTxn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WaitTxn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_WaitTxn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *WaitTxn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WaitTxn.Merge(m, src)
}
func (m *WaitTxn) XXX_Size() int {
	return m.Size()
}
func (m *WaitTxn) XXX_DiscardUnknown() {
	xxx_messageInfo_WaitTxn.DiscardUnknown(m)
}

var xxx_messageInfo_WaitTxn proto.InternalMessageInfo

func (m *WaitTxn) GetTxnID() []byte {
	if m != nil {
		return m.TxnID
	}
	return nil
}

func (m *WaitTxn) GetCreatedOn() string {
	if m != nil {
		return m.CreatedOn
	}
	return ""
}

// UnlockRequest unlock lock on remote lock service request. CN -> CN
type UnlockRequest struct {
	TxnID []byte `protobuf:"bytes,1,opt,name=TxnID,proto3" json:"TxnID,omitempty"`
	// CommitTS is the commit timestamp of the current txn. Empty if txn is
	// roll backed
	CommitTS             timestamp.Timestamp `protobuf:"bytes,2,opt,name=CommitTS,proto3" json:"CommitTS"`
	Mutations            []ExtraMutation     `protobuf:"bytes,3,rep,name=Mutations,proto3" json:"Mutations"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *UnlockRequest) Reset()         { *m = UnlockRequest{} }
func (m *UnlockRequest) String() string { return proto.CompactTextString(m) }
func (*UnlockRequest) ProtoMessage()    {}
func (*UnlockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{11}
}
func (m *UnlockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnlockRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnlockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnlockRequest.Merge(m, src)
}
func (m *UnlockRequest) XXX_Size() int {
	return m.Size()
}
func (m *UnlockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UnlockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UnlockRequest proto.InternalMessageInfo

func (m *UnlockRequest) GetTxnID() []byte {
	if m != nil {
		return m.TxnID
	}
	return nil
}

func (m *UnlockRequest) GetCommitTS() timestamp.Timestamp {
	if m != nil {
		return m.CommitTS
	}
	return timestamp.Timestamp{}
}

func (m *UnlockRequest) GetMutations() []ExtraMutation {
	if m != nil {
		return m.Mutations
	}
	return nil
}

// UnlockResponse unlock lock on remote lock service response. CN -> CN
type UnlockResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnlockResponse) Reset()         { *m = UnlockResponse{} }
func (m *UnlockResponse) String() string { return proto.CompactTextString(m) }
func (*UnlockResponse) ProtoMessage()    {}
func (*UnlockResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{12}
}
func (m *UnlockResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UnlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UnlockResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UnlockResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UnlockResponse.Merge(m, src)
}
func (m *UnlockResponse) XXX_Size() int {
	return m.Size()
}
func (m *UnlockResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UnlockResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UnlockResponse proto.InternalMessageInfo

// GetBindRequest get bind request from allocator request. CN -> TN
type GetBindRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	Table                uint64   `protobuf:"varint,2,opt,name=Table,proto3" json:"Table,omitempty"`
	Group                uint32   `protobuf:"varint,3,opt,name=Group,proto3" json:"Group,omitempty"`
	Sharding             Sharding `protobuf:"varint,4,opt,name=Sharding,proto3,enum=lock.Sharding" json:"Sharding,omitempty"`
	OriginTable          uint64   `protobuf:"varint,5,opt,name=OriginTable,proto3" json:"OriginTable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetBindRequest) Reset()         { *m = GetBindRequest{} }
func (m *GetBindRequest) String() string { return proto.CompactTextString(m) }
func (*GetBindRequest) ProtoMessage()    {}
func (*GetBindRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{13}
}
func (m *GetBindRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBindRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBindRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetBindRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBindRequest.Merge(m, src)
}
func (m *GetBindRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetBindRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBindRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetBindRequest proto.InternalMessageInfo

func (m *GetBindRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

func (m *GetBindRequest) GetTable() uint64 {
	if m != nil {
		return m.Table
	}
	return 0
}

func (m *GetBindRequest) GetGroup() uint32 {
	if m != nil {
		return m.Group
	}
	return 0
}

func (m *GetBindRequest) GetSharding() Sharding {
	if m != nil {
		return m.Sharding
	}
	return Sharding_None
}

func (m *GetBindRequest) GetOriginTable() uint64 {
	if m != nil {
		return m.OriginTable
	}
	return 0
}

// GetBindResponse get bind request from allocator response. TN -> CN
type GetBindResponse struct {
	LockTable            LockTable `protobuf:"bytes,2,opt,name=LockTable,proto3" json:"LockTable"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GetBindResponse) Reset()         { *m = GetBindResponse{} }
func (m *GetBindResponse) String() string { return proto.CompactTextString(m) }
func (*GetBindResponse) ProtoMessage()    {}
func (*GetBindResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{14}
}
func (m *GetBindResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetBindResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetBindResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetBindResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetBindResponse.Merge(m, src)
}
func (m *GetBindResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetBindResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetBindResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetBindResponse proto.InternalMessageInfo

func (m *GetBindResponse) GetLockTable() LockTable {
	if m != nil {
		return m.LockTable
	}
	return LockTable{}
}

// KeepLockTableBindRequest keep lock table bind request. CN -> TN
type KeepLockTableBindRequest struct {
	ServiceID            string      `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	Status               Status      `protobuf:"varint,2,opt,name=Status,proto3,enum=lock.Status" json:"Status,omitempty"`
	TxnIDs               [][]byte    `protobuf:"bytes,3,rep,name=TxnIDs,proto3" json:"TxnIDs,omitempty"`
	LockTables           []LockTable `protobuf:"bytes,4,rep,name=LockTables,proto3" json:"LockTables"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *KeepLockTableBindRequest) Reset()         { *m = KeepLockTableBindRequest{} }
func (m *KeepLockTableBindRequest) String() string { return proto.CompactTextString(m) }
func (*KeepLockTableBindRequest) ProtoMessage()    {}
func (*KeepLockTableBindRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{15}
}
func (m *KeepLockTableBindRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeepLockTableBindRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeepLockTableBindRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeepLockTableBindRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeepLockTableBindRequest.Merge(m, src)
}
func (m *KeepLockTableBindRequest) XXX_Size() int {
	return m.Size()
}
func (m *KeepLockTableBindRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_KeepLockTableBindRequest.DiscardUnknown(m)
}

var xxx_messageInfo_KeepLockTableBindRequest proto.InternalMessageInfo

func (m *KeepLockTableBindRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

func (m *KeepLockTableBindRequest) GetStatus() Status {
	if m != nil {
		return m.Status
	}
	return Status_ServiceLockEnable
}

func (m *KeepLockTableBindRequest) GetTxnIDs() [][]byte {
	if m != nil {
		return m.TxnIDs
	}
	return nil
}

func (m *KeepLockTableBindRequest) GetLockTables() []LockTable {
	if m != nil {
		return m.LockTables
	}
	return nil
}

// KeepLockTableBindResponse keep lock table bind response. TN -> CN
type KeepLockTableBindResponse struct {
	OK                   bool     `protobuf:"varint,1,opt,name=OK,proto3" json:"OK,omitempty"`
	Status               Status   `protobuf:"varint,2,opt,name=Status,proto3,enum=lock.Status" json:"Status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeepLockTableBindResponse) Reset()         { *m = KeepLockTableBindResponse{} }
func (m *KeepLockTableBindResponse) String() string { return proto.CompactTextString(m) }
func (*KeepLockTableBindResponse) ProtoMessage()    {}
func (*KeepLockTableBindResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{16}
}
func (m *KeepLockTableBindResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeepLockTableBindResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeepLockTableBindResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeepLockTableBindResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeepLockTableBindResponse.Merge(m, src)
}
func (m *KeepLockTableBindResponse) XXX_Size() int {
	return m.Size()
}
func (m *KeepLockTableBindResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_KeepLockTableBindResponse.DiscardUnknown(m)
}

var xxx_messageInfo_KeepLockTableBindResponse proto.InternalMessageInfo

func (m *KeepLockTableBindResponse) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

func (m *KeepLockTableBindResponse) GetStatus() Status {
	if m != nil {
		return m.Status
	}
	return Status_ServiceLockEnable
}

// SetRestartServiceRequest set restart lock service request from allocator request. operator -> TN
type SetRestartServiceRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetRestartServiceRequest) Reset()         { *m = SetRestartServiceRequest{} }
func (m *SetRestartServiceRequest) String() string { return proto.CompactTextString(m) }
func (*SetRestartServiceRequest) ProtoMessage()    {}
func (*SetRestartServiceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{17}
}
func (m *SetRestartServiceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetRestartServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetRestartServiceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetRestartServiceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetRestartServiceRequest.Merge(m, src)
}
func (m *SetRestartServiceRequest) XXX_Size() int {
	return m.Size()
}
func (m *SetRestartServiceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetRestartServiceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetRestartServiceRequest proto.InternalMessageInfo

func (m *SetRestartServiceRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

// SetRestartServiceResponse set restart lock service request from allocator response. TN -> operator
type SetRestartServiceResponse struct {
	OK                   bool     `protobuf:"varint,1,opt,name=OK,proto3" json:"OK,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetRestartServiceResponse) Reset()         { *m = SetRestartServiceResponse{} }
func (m *SetRestartServiceResponse) String() string { return proto.CompactTextString(m) }
func (*SetRestartServiceResponse) ProtoMessage()    {}
func (*SetRestartServiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{18}
}
func (m *SetRestartServiceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetRestartServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetRestartServiceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SetRestartServiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetRestartServiceResponse.Merge(m, src)
}
func (m *SetRestartServiceResponse) XXX_Size() int {
	return m.Size()
}
func (m *SetRestartServiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetRestartServiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetRestartServiceResponse proto.InternalMessageInfo

func (m *SetRestartServiceResponse) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

// CanRestartServiceRequest can restart lock service request from allocator request. operator -> TN
type CanRestartServiceRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CanRestartServiceRequest) Reset()         { *m = CanRestartServiceRequest{} }
func (m *CanRestartServiceRequest) String() string { return proto.CompactTextString(m) }
func (*CanRestartServiceRequest) ProtoMessage()    {}
func (*CanRestartServiceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{19}
}
func (m *CanRestartServiceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CanRestartServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CanRestartServiceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CanRestartServiceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CanRestartServiceRequest.Merge(m, src)
}
func (m *CanRestartServiceRequest) XXX_Size() int {
	return m.Size()
}
func (m *CanRestartServiceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CanRestartServiceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CanRestartServiceRequest proto.InternalMessageInfo

func (m *CanRestartServiceRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

// CanRestartServiceResponse can restart lock service request from allocator response. TN -> operator
type CanRestartServiceResponse struct {
	OK                   bool     `protobuf:"varint,1,opt,name=OK,proto3" json:"OK,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CanRestartServiceResponse) Reset()         { *m = CanRestartServiceResponse{} }
func (m *CanRestartServiceResponse) String() string { return proto.CompactTextString(m) }
func (*CanRestartServiceResponse) ProtoMessage()    {}
func (*CanRestartServiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{20}
}
func (m *CanRestartServiceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CanRestartServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CanRestartServiceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CanRestartServiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CanRestartServiceResponse.Merge(m, src)
}
func (m *CanRestartServiceResponse) XXX_Size() int {
	return m.Size()
}
func (m *CanRestartServiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CanRestartServiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CanRestartServiceResponse proto.InternalMessageInfo

func (m *CanRestartServiceResponse) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

// RemainTxnInServiceRequest get remain txn in service request from allocator request. operator -> TN
type RemainTxnInServiceRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RemainTxnInServiceRequest) Reset()         { *m = RemainTxnInServiceRequest{} }
func (m *RemainTxnInServiceRequest) String() string { return proto.CompactTextString(m) }
func (*RemainTxnInServiceRequest) ProtoMessage()    {}
func (*RemainTxnInServiceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{21}
}
func (m *RemainTxnInServiceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemainTxnInServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemainTxnInServiceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemainTxnInServiceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemainTxnInServiceRequest.Merge(m, src)
}
func (m *RemainTxnInServiceRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemainTxnInServiceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemainTxnInServiceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemainTxnInServiceRequest proto.InternalMessageInfo

func (m *RemainTxnInServiceRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

// RemainTxnInServiceResponse get remain txn in service request from allocator response. TN -> operator
type RemainTxnInServiceResponse struct {
	RemainTxn            int32    `protobuf:"varint,1,opt,name=RemainTxn,proto3" json:"RemainTxn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RemainTxnInServiceResponse) Reset()         { *m = RemainTxnInServiceResponse{} }
func (m *RemainTxnInServiceResponse) String() string { return proto.CompactTextString(m) }
func (*RemainTxnInServiceResponse) ProtoMessage()    {}
func (*RemainTxnInServiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{22}
}
func (m *RemainTxnInServiceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemainTxnInServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemainTxnInServiceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemainTxnInServiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemainTxnInServiceResponse.Merge(m, src)
}
func (m *RemainTxnInServiceResponse) XXX_Size() int {
	return m.Size()
}
func (m *RemainTxnInServiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RemainTxnInServiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RemainTxnInServiceResponse proto.InternalMessageInfo

func (m *RemainTxnInServiceResponse) GetRemainTxn() int32 {
	if m != nil {
		return m.RemainTxn
	}
	return 0
}

// KeepRemoteLockRequest keep lock on remote lockservice request. CN -> CN
type KeepRemoteLockRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeepRemoteLockRequest) Reset()         { *m = KeepRemoteLockRequest{} }
func (m *KeepRemoteLockRequest) String() string { return proto.CompactTextString(m) }
func (*KeepRemoteLockRequest) ProtoMessage()    {}
func (*KeepRemoteLockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{23}
}
func (m *KeepRemoteLockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeepRemoteLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeepRemoteLockRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeepRemoteLockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeepRemoteLockRequest.Merge(m, src)
}
func (m *KeepRemoteLockRequest) XXX_Size() int {
	return m.Size()
}
func (m *KeepRemoteLockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_KeepRemoteLockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_KeepRemoteLockRequest proto.InternalMessageInfo

func (m *KeepRemoteLockRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

// KeepRemoteLockResponse keep lock on remote lockservice response. TN -> CN
type KeepRemoteLockResponse struct {
	OK                   bool     `protobuf:"varint,1,opt,name=OK,proto3" json:"OK,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeepRemoteLockResponse) Reset()         { *m = KeepRemoteLockResponse{} }
func (m *KeepRemoteLockResponse) String() string { return proto.CompactTextString(m) }
func (*KeepRemoteLockResponse) ProtoMessage()    {}
func (*KeepRemoteLockResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{24}
}
func (m *KeepRemoteLockResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeepRemoteLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeepRemoteLockResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeepRemoteLockResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeepRemoteLockResponse.Merge(m, src)
}
func (m *KeepRemoteLockResponse) XXX_Size() int {
	return m.Size()
}
func (m *KeepRemoteLockResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_KeepRemoteLockResponse.DiscardUnknown(m)
}

var xxx_messageInfo_KeepRemoteLockResponse proto.InternalMessageInfo

func (m *KeepRemoteLockResponse) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

// ValidateServiceRequest validate if lock service alive request. TN -> CN
type ValidateServiceRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ValidateServiceRequest) Reset()         { *m = ValidateServiceRequest{} }
func (m *ValidateServiceRequest) String() string { return proto.CompactTextString(m) }
func (*ValidateServiceRequest) ProtoMessage()    {}
func (*ValidateServiceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{25}
}
func (m *ValidateServiceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidateServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidateServiceRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidateServiceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidateServiceRequest.Merge(m, src)
}
func (m *ValidateServiceRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidateServiceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidateServiceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidateServiceRequest proto.InternalMessageInfo

func (m *ValidateServiceRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

// KeepLockTableBindResponse keep lock table bind response. CN -> DN
type ValidateServiceResponse struct {
	OK                   bool     `protobuf:"varint,1,opt,name=OK,proto3" json:"OK,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ValidateServiceResponse) Reset()         { *m = ValidateServiceResponse{} }
func (m *ValidateServiceResponse) String() string { return proto.CompactTextString(m) }
func (*ValidateServiceResponse) ProtoMessage()    {}
func (*ValidateServiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{26}
}
func (m *ValidateServiceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidateServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidateServiceResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidateServiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidateServiceResponse.Merge(m, src)
}
func (m *ValidateServiceResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidateServiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidateServiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidateServiceResponse proto.InternalMessageInfo

func (m *ValidateServiceResponse) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

// CannotCommitRequest cannot commit request. CN -> TN
type CannotCommitRequest struct {
	OrphanTxnList        []OrphanTxn `protobuf:"bytes,1,rep,name=OrphanTxnList,proto3" json:"OrphanTxnList"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *CannotCommitRequest) Reset()         { *m = CannotCommitRequest{} }
func (m *CannotCommitRequest) String() string { return proto.CompactTextString(m) }
func (*CannotCommitRequest) ProtoMessage()    {}
func (*CannotCommitRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{27}
}
func (m *CannotCommitRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CannotCommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CannotCommitRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CannotCommitRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CannotCommitRequest.Merge(m, src)
}
func (m *CannotCommitRequest) XXX_Size() int {
	return m.Size()
}
func (m *CannotCommitRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CannotCommitRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CannotCommitRequest proto.InternalMessageInfo

func (m *CannotCommitRequest) GetOrphanTxnList() []OrphanTxn {
	if m != nil {
		return m.OrphanTxnList
	}
	return nil
}

// CannotCommitResponse cannot commit response. TN -> CN
type CannotCommitResponse struct {
	CommittingTxn        [][]byte `protobuf:"bytes,1,rep,name=CommittingTxn,proto3" json:"CommittingTxn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CannotCommitResponse) Reset()         { *m = CannotCommitResponse{} }
func (m *CannotCommitResponse) String() string { return proto.CompactTextString(m) }
func (*CannotCommitResponse) ProtoMessage()    {}
func (*CannotCommitResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{28}
}
func (m *CannotCommitResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CannotCommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CannotCommitResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CannotCommitResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CannotCommitResponse.Merge(m, src)
}
func (m *CannotCommitResponse) XXX_Size() int {
	return m.Size()
}
func (m *CannotCommitResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CannotCommitResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CannotCommitResponse proto.InternalMessageInfo

func (m *CannotCommitResponse) GetCommittingTxn() [][]byte {
	if m != nil {
		return m.CommittingTxn
	}
	return nil
}

type GetActiveTxnRequest struct {
	ServiceID            string   `protobuf:"bytes,1,opt,name=ServiceID,proto3" json:"ServiceID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetActiveTxnRequest) Reset()         { *m = GetActiveTxnRequest{} }
func (m *GetActiveTxnRequest) String() string { return proto.CompactTextString(m) }
func (*GetActiveTxnRequest) ProtoMessage()    {}
func (*GetActiveTxnRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{29}
}
func (m *GetActiveTxnRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetActiveTxnRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetActiveTxnRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetActiveTxnRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetActiveTxnRequest.Merge(m, src)
}
func (m *GetActiveTxnRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetActiveTxnRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetActiveTxnRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetActiveTxnRequest proto.InternalMessageInfo

func (m *GetActiveTxnRequest) GetServiceID() string {
	if m != nil {
		return m.ServiceID
	}
	return ""
}

type GetActiveTxnResponse struct {
	Valid                bool     `protobuf:"varint,1,opt,name=Valid,proto3" json:"Valid,omitempty"`
	Txn                  [][]byte `protobuf:"bytes,2,rep,name=Txn,proto3" json:"Txn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetActiveTxnResponse) Reset()         { *m = GetActiveTxnResponse{} }
func (m *GetActiveTxnResponse) String() string { return proto.CompactTextString(m) }
func (*GetActiveTxnResponse) ProtoMessage()    {}
func (*GetActiveTxnResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{30}
}
func (m *GetActiveTxnResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetActiveTxnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetActiveTxnResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetActiveTxnResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetActiveTxnResponse.Merge(m, src)
}
func (m *GetActiveTxnResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetActiveTxnResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetActiveTxnResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetActiveTxnResponse proto.InternalMessageInfo

func (m *GetActiveTxnResponse) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

func (m *GetActiveTxnResponse) GetTxn() [][]byte {
	if m != nil {
		return m.Txn
	}
	return nil
}

type OrphanTxn struct {
	Service              string   `protobuf:"bytes,1,opt,name=Service,proto3" json:"Service,omitempty"`
	Txn                  [][]byte `protobuf:"bytes,2,rep,name=Txn,proto3" json:"Txn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OrphanTxn) Reset()         { *m = OrphanTxn{} }
func (m *OrphanTxn) String() string { return proto.CompactTextString(m) }
func (*OrphanTxn) ProtoMessage()    {}
func (*OrphanTxn) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{31}
}
func (m *OrphanTxn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OrphanTxn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OrphanTxn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OrphanTxn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrphanTxn.Merge(m, src)
}
func (m *OrphanTxn) XXX_Size() int {
	return m.Size()
}
func (m *OrphanTxn) XXX_DiscardUnknown() {
	xxx_messageInfo_OrphanTxn.DiscardUnknown(m)
}

var xxx_messageInfo_OrphanTxn proto.InternalMessageInfo

func (m *OrphanTxn) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *OrphanTxn) GetTxn() [][]byte {
	if m != nil {
		return m.Txn
	}
	return nil
}

// Result result is used to tell the caller the result of the lock operation.
type Result struct {
	// LockedOn lock is locked on which locktable
	LockedOn LockTable `protobuf:"bytes,1,opt,name=LockedOn,proto3" json:"LockedOn"`
	// HasConflict if true means encounter lock conflict
	HasConflict bool `protobuf:"varint,2,opt,name=HasConflict,proto3" json:"HasConflict,omitempty"`
	// HasPrevCommit if HasPrevCommit && HasConflict, Timestamp is the latest commit
	// timestamp.
	HasPrevCommit bool `protobuf:"varint,3,opt,name=HasPrevCommit,proto3" json:"HasPrevCommit,omitempty"`
	// Timestamp is used to help determine which version of RC should be queried
	// under the RC isolation level, this timestamp ensures that the latest data
	// is always read.
	Timestamp timestamp.Timestamp `protobuf:"bytes,4,opt,name=Timestamp,proto3" json:"Timestamp"`
	// TableDefChanged conflict with ddl lock, need rebuild plan to get new table def
	TableDefChanged      bool     `protobuf:"varint,5,opt,name=TableDefChanged,proto3" json:"TableDefChanged,omitempty"`
	ConflictKey          []byte   `protobuf:"bytes,6,opt,name=ConflictKey,proto3" json:"ConflictKey,omitempty"`
	ConflictTxn          []byte   `protobuf:"bytes,7,opt,name=ConflictTxn,proto3" json:"ConflictTxn,omitempty"`
	PrevWaiter           []byte   `protobuf:"bytes,8,opt,name=PrevWaiter,proto3" json:"PrevWaiter,omitempty"`
	Waiters              uint32   `protobuf:"varint,9,opt,name=Waiters,proto3" json:"Waiters,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Result) Reset()         { *m = Result{} }
func (m *Result) String() string { return proto.CompactTextString(m) }
func (*Result) ProtoMessage()    {}
func (*Result) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{32}
}
func (m *Result) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Result.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Result) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Result.Merge(m, src)
}
func (m *Result) XXX_Size() int {
	return m.Size()
}
func (m *Result) XXX_DiscardUnknown() {
	xxx_messageInfo_Result.DiscardUnknown(m)
}

var xxx_messageInfo_Result proto.InternalMessageInfo

func (m *Result) GetLockedOn() LockTable {
	if m != nil {
		return m.LockedOn
	}
	return LockTable{}
}

func (m *Result) GetHasConflict() bool {
	if m != nil {
		return m.HasConflict
	}
	return false
}

func (m *Result) GetHasPrevCommit() bool {
	if m != nil {
		return m.HasPrevCommit
	}
	return false
}

func (m *Result) GetTimestamp() timestamp.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return timestamp.Timestamp{}
}

func (m *Result) GetTableDefChanged() bool {
	if m != nil {
		return m.TableDefChanged
	}
	return false
}

func (m *Result) GetConflictKey() []byte {
	if m != nil {
		return m.ConflictKey
	}
	return nil
}

func (m *Result) GetConflictTxn() []byte {
	if m != nil {
		return m.ConflictTxn
	}
	return nil
}

func (m *Result) GetPrevWaiter() []byte {
	if m != nil {
		return m.PrevWaiter
	}
	return nil
}

func (m *Result) GetWaiters() uint32 {
	if m != nil {
		return m.Waiters
	}
	return 0
}

type ExtraMutation struct {
	Key                  []byte   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Skip                 bool     `protobuf:"varint,2,opt,name=skip,proto3" json:"skip,omitempty"`
	ReplaceTo            []byte   `protobuf:"bytes,3,opt,name=replaceTo,proto3" json:"replaceTo,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExtraMutation) Reset()         { *m = ExtraMutation{} }
func (m *ExtraMutation) String() string { return proto.CompactTextString(m) }
func (*ExtraMutation) ProtoMessage()    {}
func (*ExtraMutation) Descriptor() ([]byte, []int) {
	return fileDescriptor_164ad2988c7acaf1, []int{33}
}
func (m *ExtraMutation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExtraMutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExtraMutation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExtraMutation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtraMutation.Merge(m, src)
}
func (m *ExtraMutation) XXX_Size() int {
	return m.Size()
}
func (m *ExtraMutation) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtraMutation.DiscardUnknown(m)
}

var xxx_messageInfo_ExtraMutation proto.InternalMessageInfo

func (m *ExtraMutation) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ExtraMutation) GetSkip() bool {
	if m != nil {
		return m.Skip
	}
	return false
}

func (m *ExtraMutation) GetReplaceTo() []byte {
	if m != nil {
		return m.ReplaceTo
	}
	return nil
}

func init() {
	proto.RegisterEnum("lock.Granularity", Granularity_name, Granularity_value)
	proto.RegisterEnum("lock.LockMode", LockMode_name, LockMode_value)
	proto.RegisterEnum("lock.WaitPolicy", WaitPolicy_name, WaitPolicy_value)
	proto.RegisterEnum("lock.Sharding", Sharding_name, Sharding_value)
	proto.RegisterEnum("lock.Method", Method_name, Method_value)
	proto.RegisterEnum("lock.Status", Status_name, Status_value)
	proto.RegisterType((*LockOptions)(nil), "lock.LockOptions")
	proto.RegisterType((*LockTable)(nil), "lock.LockTable")
	proto.RegisterType((*Request)(nil), "lock.Request")
	proto.RegisterType((*Response)(nil), "lock.Response")
	proto.RegisterType((*LockRequest)(nil), "lock.LockRequest")
	proto.RegisterType((*LockResponse)(nil), "lock.LockResponse")
	proto.RegisterType((*GetTxnLockRequest)(nil), "lock.GetTxnLockRequest")
	proto.RegisterType((*GetTxnLockResponse)(nil), "lock.GetTxnLockResponse")
	proto.RegisterType((*GetWaitingListRequest)(nil), "lock.GetWaitingListRequest")
	proto.RegisterType((*GetWaitingListResponse)(nil), "lock.GetWaitingListResponse")
	proto.RegisterType((*WaitTxn)(nil), "lock.WaitTxn")
	proto.RegisterType((*UnlockRequest)(nil), "lock.UnlockRequest")
	proto.RegisterType((*UnlockResponse)(nil), "lock.UnlockResponse")
	proto.RegisterType((*GetBindRequest)(nil), "lock.GetBindRequest")
	proto.RegisterType((*GetBindResponse)(nil), "lock.GetBindResponse")
	proto.RegisterType((*KeepLockTableBindRequest)(nil), "lock.KeepLockTableBindRequest")
	proto.RegisterType((*KeepLockTableBindResponse)(nil), "lock.KeepLockTableBindResponse")
	proto.RegisterType((*SetRestartServiceRequest)(nil), "lock.SetRestartServiceRequest")
	proto.RegisterType((*SetRestartServiceResponse)(nil), "lock.SetRestartServiceResponse")
	proto.RegisterType((*CanRestartServiceRequest)(nil), "lock.CanRestartServiceRequest")
	proto.RegisterType((*CanRestartServiceResponse)(nil), "lock.CanRestartServiceResponse")
	proto.RegisterType((*RemainTxnInServiceRequest)(nil), "lock.RemainTxnInServiceRequest")
	proto.RegisterType((*RemainTxnInServiceResponse)(nil), "lock.RemainTxnInServiceResponse")
	proto.RegisterType((*KeepRemoteLockRequest)(nil), "lock.KeepRemoteLockRequest")
	proto.RegisterType((*KeepRemoteLockResponse)(nil), "lock.KeepRemoteLockResponse")
	proto.RegisterType((*ValidateServiceRequest)(nil), "lock.ValidateServiceRequest")
	proto.RegisterType((*ValidateServiceResponse)(nil), "lock.ValidateServiceResponse")
	proto.RegisterType((*CannotCommitRequest)(nil), "lock.CannotCommitRequest")
	proto.RegisterType((*CannotCommitResponse)(nil), "lock.CannotCommitResponse")
	proto.RegisterType((*GetActiveTxnRequest)(nil), "lock.GetActiveTxnRequest")
	proto.RegisterType((*GetActiveTxnResponse)(nil), "lock.GetActiveTxnResponse")
	proto.RegisterType((*OrphanTxn)(nil), "lock.OrphanTxn")
	proto.RegisterType((*Result)(nil), "lock.Result")
	proto.RegisterType((*ExtraMutation)(nil), "lock.ExtraMutation")
}

func init() { proto.RegisterFile("lock.proto", fileDescriptor_164ad2988c7acaf1) }

var fileDescriptor_164ad2988c7acaf1 = []byte{
	// 1873 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xdd, 0x72, 0xdb, 0xc6,
	0x15, 0x16, 0x48, 0x8a, 0x3f, 0x07, 0xfc, 0x81, 0xd6, 0xb2, 0x02, 0xbb, 0xa9, 0xcc, 0x62, 0x9c,
	0x19, 0x86, 0x69, 0xad, 0xb1, 0x5c, 0x27, 0xa9, 0xd3, 0xb8, 0x53, 0x4b, 0xb6, 0xe2, 0xd8, 0x8e,
	0xd2, 0x25, 0xed, 0xce, 0xf4, 0x0e, 0x22, 0xd7, 0x14, 0x46, 0x24, 0xc0, 0x02, 0x4b, 0x9b, 0x7a,
	0x83, 0x3e, 0x41, 0xa7, 0x37, 0xbd, 0xef, 0x4d, 0x6f, 0xfa, 0x14, 0xb9, 0xcc, 0x4c, 0xef, 0x3b,
	0xad, 0x67, 0xfa, 0x06, 0x7d, 0x80, 0xce, 0xfe, 0x00, 0xd8, 0xc5, 0x8f, 0x18, 0xe7, 0x0e, 0x7b,
	0xce, 0xd9, 0x73, 0xf6, 0x1c, 0xec, 0x7e, 0xe7, 0xdb, 0x05, 0x98, 0x07, 0x93, 0x8b, 0x3b, 0xcb,
	0x30, 0xa0, 0x01, 0xaa, 0xb1, 0xef, 0x9b, 0xbf, 0x98, 0x79, 0xf4, 0x7c, 0x75, 0x76, 0x67, 0x12,
	0x2c, 0x0e, 0x66, 0xc1, 0x2c, 0x38, 0xe0, 0xca, 0xb3, 0xd5, 0x6b, 0x3e, 0xe2, 0x03, 0xfe, 0x25,
	0x26, 0xdd, 0xec, 0x51, 0x6f, 0x41, 0x22, 0xea, 0x2e, 0x96, 0x42, 0xe0, 0xfc, 0xaf, 0x02, 0xe6,
	0xf3, 0x60, 0x72, 0x71, 0xba, 0xa4, 0x5e, 0xe0, 0x47, 0xe8, 0x1e, 0x98, 0x27, 0xa1, 0xeb, 0xaf,
	0xe6, 0x6e, 0xe8, 0xd1, 0x4b, 0xdb, 0xe8, 0x1b, 0x83, 0xee, 0xe1, 0xce, 0x1d, 0x1e, 0x57, 0x51,
	0x60, 0xd5, 0x0a, 0x39, 0x50, 0x7b, 0x11, 0x4c, 0x89, 0x5d, 0xe1, 0xd6, 0x5d, 0x61, 0xcd, 0xbc,
	0x32, 0x29, 0xe6, 0x3a, 0x34, 0x80, 0xfa, 0xb7, 0xc1, 0xdc, 0x9b, 0x5c, 0xda, 0x55, 0x6e, 0x65,
	0x09, 0xab, 0xdf, 0xbb, 0x1e, 0x15, 0x72, 0x2c, 0xf5, 0xe8, 0x43, 0x68, 0x3d, 0x09, 0xc2, 0xb7,
	0x6e, 0x38, 0x1d, 0x07, 0x76, 0xad, 0x6f, 0x0c, 0x5a, 0x38, 0x15, 0xa0, 0x01, 0xf4, 0xc6, 0xee,
	0xd9, 0x9c, 0x1c, 0x93, 0xd7, 0x47, 0xe7, 0xae, 0x3f, 0x23, 0x53, 0x7b, 0xbb, 0x6f, 0x0c, 0x9a,
	0x38, 0x2b, 0x66, 0x7e, 0x30, 0xa1, 0xe1, 0x25, 0x0b, 0x61, 0xd7, 0xfb, 0xc6, 0xa0, 0x8a, 0x53,
	0x01, 0xda, 0x85, 0xed, 0x93, 0x30, 0x58, 0x2d, 0xed, 0x46, 0xdf, 0x18, 0x74, 0xb0, 0x18, 0xa0,
	0x21, 0x34, 0x47, 0xe7, 0x6e, 0x38, 0xf5, 0xfc, 0x99, 0xdd, 0x54, 0xb3, 0x89, 0xa5, 0x38, 0xd1,
	0xa3, 0x07, 0x00, 0x23, 0xdf, 0x5d, 0x8e, 0xce, 0x03, 0x3a, 0x8e, 0xec, 0x56, 0xdf, 0x18, 0x98,
	0x87, 0xbb, 0x77, 0xd2, 0x02, 0x8f, 0xe3, 0xaf, 0x47, 0xb5, 0xef, 0xfe, 0x75, 0x6b, 0x0b, 0x2b,
	0xd6, 0xce, 0x3f, 0x0d, 0x68, 0xb1, 0x02, 0xf1, 0x35, 0xb3, 0xb5, 0xf0, 0x0f, 0x5e, 0xee, 0x1a,
	0x16, 0x03, 0xb6, 0xfe, 0x11, 0x09, 0xdf, 0x78, 0x13, 0xf2, 0xf4, 0x98, 0x97, 0xb6, 0x85, 0x53,
	0x01, 0xb2, 0xa1, 0xf1, 0x8a, 0x84, 0x91, 0x17, 0xf8, 0xbc, 0xa0, 0x35, 0x1c, 0x0f, 0x99, 0xb7,
	0x57, 0xee, 0xdc, 0x9b, 0xf2, 0xda, 0x35, 0xb1, 0x18, 0xa4, 0xf9, 0x6e, 0x97, 0xe5, 0x5b, 0xdf,
	0x90, 0x6f, 0x1f, 0xcc, 0xd3, 0xd0, 0x9b, 0x79, 0xbe, 0x58, 0x6b, 0x83, 0x47, 0x55, 0x45, 0xce,
	0x5f, 0x9a, 0xd0, 0xc0, 0xe4, 0x8f, 0x2b, 0x12, 0x51, 0x51, 0x7d, 0xfe, 0xf9, 0xf4, 0x58, 0xe6,
	0x95, 0x0a, 0xd0, 0x3d, 0x25, 0x7d, 0x9e, 0x9b, 0x79, 0xd8, 0x4b, 0xb7, 0x0d, 0x17, 0xcb, 0xaa,
	0x29, 0x65, 0xba, 0x0d, 0xf5, 0x17, 0x84, 0x9e, 0x07, 0x53, 0xb9, 0x85, 0xda, 0x62, 0x86, 0x90,
	0x61, 0xa9, 0x43, 0x9f, 0x40, 0x8d, 0x4d, 0xe1, 0xd9, 0x9b, 0xf1, 0xd6, 0x65, 0x12, 0x19, 0x5d,
	0xfa, 0xe5, 0x46, 0xe8, 0x2e, 0xd4, 0x5f, 0xfa, 0xcc, 0x82, 0x97, 0xc5, 0x3c, 0xbc, 0x26, 0xcc,
	0x85, 0x4c, 0x9f, 0x20, 0x0d, 0xd1, 0x97, 0x00, 0x27, 0x84, 0x8e, 0xd7, 0x3e, 0x8f, 0x52, 0xe7,
	0xd3, 0x3e, 0x90, 0x07, 0x24, 0x91, 0xeb, 0x53, 0x95, 0x09, 0xe8, 0x29, 0x74, 0x4f, 0x08, 0x65,
	0x5b, 0xd0, 0xf3, 0x67, 0xcf, 0xbd, 0x88, 0xf2, 0x42, 0x9a, 0x87, 0x3f, 0x49, 0x5c, 0x28, 0x3a,
	0xdd, 0x4d, 0x66, 0x22, 0xfa, 0x25, 0x34, 0x4e, 0x08, 0x7d, 0xe4, 0xf9, 0x53, 0xbe, 0x57, 0xd9,
	0xee, 0x8b, 0x7d, 0x30, 0xa1, 0x3e, 0x39, 0x36, 0x45, 0x18, 0x76, 0x9e, 0x11, 0xb2, 0x4c, 0xeb,
	0xcc, 0xe6, 0x8b, 0xdd, 0xbb, 0x2f, 0xe6, 0xe7, 0xd4, 0xba, 0xa7, 0xfc, 0x74, 0x96, 0x14, 0x13,
	0x62, 0xb2, 0x08, 0x28, 0xe1, 0x75, 0x01, 0x35, 0x29, 0x5d, 0x97, 0x49, 0x4a, 0x57, 0xa2, 0xe7,
	0xd0, 0xe3, 0x1b, 0xd6, 0xa5, 0x44, 0x6e, 0x76, 0xdb, 0xe4, 0xbe, 0x3e, 0x14, 0xbe, 0x32, 0x4a,
	0xdd, 0x59, 0x76, 0x2a, 0x3a, 0x82, 0xf6, 0x91, 0xeb, 0xfb, 0x01, 0x3d, 0x0a, 0x16, 0x0b, 0x8f,
	0xda, 0x6d, 0xee, 0xea, 0x86, 0x70, 0xa5, 0x6a, 0x74, 0x3f, 0xda, 0x24, 0xe6, 0xe4, 0x84, 0xd0,
	0xdf, 0x4e, 0xa8, 0xf7, 0x86, 0x8c, 0xd7, 0xbe, 0xdd, 0x51, 0x9d, 0xa8, 0x9a, 0x8c, 0x13, 0x55,
	0xc5, 0xca, 0x3e, 0x22, 0x14, 0x33, 0x44, 0x08, 0x69, 0x9c, 0x59, 0x57, 0x2d, 0x7b, 0x4e, 0x9d,
	0x29, 0x7b, 0x4e, 0xcf, 0x7c, 0x1e, 0xb9, 0x7e, 0xc6, 0x67, 0x4f, 0xf5, 0x99, 0x53, 0x67, 0x7c,
	0xe6, 0xf4, 0xe8, 0x25, 0x20, 0x4c, 0x16, 0xae, 0xe7, 0x8f, 0xd7, 0xfe, 0x53, 0x3f, 0x76, 0x6a,
	0x71, 0xa7, 0xb7, 0x84, 0xd3, 0xbc, 0x5e, 0xf7, 0x5a, 0xe0, 0xc0, 0xf9, 0x47, 0x13, 0x9a, 0x98,
	0x44, 0xcb, 0xc0, 0x8f, 0xc8, 0x06, 0x6c, 0x48, 0x8f, 0x79, 0xe5, 0x8a, 0x63, 0xbe, 0x0b, 0xdb,
	0x8f, 0xc3, 0x30, 0x08, 0x39, 0x16, 0xb4, 0xb1, 0x18, 0xa0, 0x8f, 0xa1, 0xf1, 0x0d, 0x79, 0xcb,
	0xb7, 0x74, 0xad, 0x10, 0x55, 0x70, 0xac, 0x47, 0x3f, 0x97, 0x38, 0x21, 0x0e, 0x3e, 0x52, 0x71,
	0x42, 0x2c, 0x53, 0x03, 0x8a, 0xc3, 0x04, 0x28, 0xea, 0xea, 0x51, 0x8b, 0x81, 0x42, 0x9b, 0x11,
	0x23, 0xc5, 0x43, 0x0d, 0x29, 0xc4, 0x31, 0xb7, 0xf3, 0x48, 0xa1, 0xcd, 0x55, 0xa1, 0xe2, 0xeb,
	0x1c, 0x54, 0x34, 0xd5, 0x93, 0x90, 0x85, 0x0a, 0xcd, 0x4f, 0x16, 0x2b, 0xee, 0xa7, 0x58, 0x21,
	0xce, 0xfa, 0xf5, 0x0c, 0x56, 0x68, 0xb3, 0x13, 0xb0, 0x18, 0x15, 0x81, 0x05, 0xa8, 0x9b, 0xa1,
	0x00, 0x2c, 0x34, 0x57, 0x05, 0x68, 0xf1, 0x75, 0x0e, 0x2d, 0xb4, 0x13, 0x9e, 0x45, 0x0b, 0x3d,
	0xaf, 0x0c, 0x5c, 0xbc, 0xc8, 0xc3, 0x85, 0x38, 0xe3, 0x3f, 0x2d, 0x81, 0x0b, 0xcd, 0x5b, 0x0e,
	0x2f, 0x8e, 0x33, 0x78, 0x21, 0x8e, 0xfa, 0xcd, 0x22, 0xbc, 0xd0, 0x1c, 0xe9, 0x80, 0x71, 0x9c,
	0x01, 0x8c, 0xae, 0xea, 0x45, 0x07, 0x0c, 0xdd, 0x8b, 0x86, 0x18, 0xa3, 0x22, 0xc4, 0xe8, 0xa9,
	0xb5, 0x2f, 0x40, 0x0c, 0xbd, 0xf6, 0x79, 0xc8, 0x18, 0x15, 0x41, 0x86, 0x76, 0xba, 0x0b, 0x20,
	0x43, 0x77, 0x9a, 0xc7, 0x8c, 0x57, 0x85, 0x98, 0xb1, 0xc3, 0xbd, 0xf6, 0xcb, 0x31, 0x43, 0x73,
	0x5b, 0x04, 0x1a, 0x7f, 0x32, 0x04, 0x39, 0x8d, 0x39, 0x05, 0xe3, 0x49, 0x6b, 0x5f, 0x62, 0x46,
	0x1b, 0x8b, 0xc1, 0x06, 0x9e, 0x84, 0xa0, 0x86, 0x83, 0xb7, 0x91, 0x5d, 0xed, 0x57, 0x07, 0x6d,
	0xcc, 0xbf, 0xd1, 0x5d, 0x68, 0x48, 0xbe, 0x9b, 0x67, 0x09, 0x52, 0x11, 0x1f, 0x04, 0x39, 0x74,
	0x1e, 0x40, 0x5b, 0xdd, 0x8d, 0x68, 0x08, 0x75, 0x4c, 0xa2, 0xd5, 0x9c, 0xf2, 0xb5, 0x98, 0x31,
	0x48, 0x09, 0x59, 0x8c, 0x03, 0x62, 0xe4, 0x7c, 0x01, 0x3b, 0x39, 0x66, 0x50, 0x92, 0x8b, 0x05,
	0x55, 0x1c, 0xbc, 0xe5, 0x59, 0xb4, 0x31, 0xfb, 0x74, 0x5c, 0x40, 0x79, 0xb0, 0x90, 0x1c, 0x6f,
	0x25, 0x18, 0xe3, 0x36, 0x16, 0x03, 0x74, 0x1f, 0x4c, 0x15, 0x2d, 0x2a, 0xfd, 0xea, 0xc0, 0x3c,
	0xec, 0xa4, 0x44, 0x7b, 0xbc, 0xf6, 0xe5, 0xd2, 0x54, 0x3b, 0xe7, 0x21, 0x5c, 0x2f, 0xa4, 0x1d,
	0xe8, 0x23, 0xa8, 0xb2, 0xed, 0x2b, 0x32, 0x2c, 0xf4, 0xc3, 0xf4, 0xce, 0x29, 0xec, 0x15, 0x63,
	0x51, 0x76, 0x41, 0xc6, 0x0f, 0x5c, 0xd0, 0x97, 0xd0, 0x90, 0xda, 0xf2, 0x5f, 0x7e, 0x14, 0x12,
	0x97, 0x92, 0xe9, 0xa9, 0x1f, 0xff, 0xf2, 0x44, 0xe0, 0xfc, 0xd9, 0x80, 0x8e, 0xc6, 0xe0, 0x4a,
	0xbc, 0x7c, 0x0a, 0x4d, 0x71, 0x60, 0xc7, 0x23, 0xc9, 0x41, 0xaf, 0xa2, 0xef, 0x89, 0x2d, 0xfa,
	0x0c, 0x5a, 0x2f, 0x56, 0xd4, 0x15, 0x1b, 0xa8, 0xca, 0x73, 0x92, 0xbc, 0xf1, 0xf1, 0x9a, 0x86,
	0x6e, 0xac, 0x8b, 0x09, 0x6c, 0x62, 0xeb, 0x58, 0xd0, 0xd5, 0x1b, 0x86, 0xf3, 0x37, 0x83, 0x63,
	0xbc, 0x42, 0xb2, 0xf4, 0xed, 0x6c, 0x64, 0xb7, 0x73, 0x72, 0x55, 0xa8, 0xa8, 0x57, 0x85, 0x84,
	0xdc, 0x57, 0xcb, 0xc8, 0x7d, 0xed, 0xfd, 0xc8, 0xfd, 0x76, 0x9e, 0xdc, 0x3f, 0x81, 0x5e, 0xa6,
	0x59, 0xfc, 0x28, 0x16, 0xef, 0xfc, 0xdd, 0x00, 0xbb, 0x8c, 0x61, 0x6e, 0x48, 0xfe, 0x36, 0xd4,
	0x47, 0xd4, 0xa5, 0xab, 0x48, 0x67, 0x06, 0x42, 0x86, 0xa5, 0x0e, 0xed, 0x41, 0x9d, 0xff, 0xdf,
	0xf8, 0xcc, 0xcb, 0x11, 0xba, 0x0f, 0x90, 0xc4, 0x64, 0x07, 0xbf, 0x5a, 0xbe, 0x5c, 0xc5, 0xd0,
	0xf9, 0x1d, 0xdc, 0x28, 0xed, 0x71, 0xa8, 0x0b, 0x95, 0xd3, 0x67, 0x7c, 0xa1, 0x4d, 0x5c, 0x39,
	0x7d, 0xf6, 0xc3, 0x56, 0xe8, 0x7c, 0x0e, 0x76, 0x19, 0xd9, 0xbb, 0xba, 0x02, 0xce, 0x27, 0x70,
	0xa3, 0x14, 0xf4, 0xb3, 0x8b, 0x61, 0x61, 0xca, 0xf8, 0xdf, 0xe6, 0x30, 0xa5, 0x6d, 0x20, 0x17,
	0xe6, 0x57, 0x70, 0xa3, 0x94, 0x11, 0x6e, 0x88, 0xf3, 0x00, 0x6e, 0x96, 0x37, 0x06, 0x41, 0x13,
	0xa5, 0x56, 0x02, 0x5d, 0x2a, 0x70, 0xee, 0xc3, 0xf5, 0xc2, 0x7b, 0xc5, 0x86, 0x90, 0x03, 0xd8,
	0x2b, 0x26, 0x18, 0xb9, 0xbc, 0x3e, 0x85, 0xbd, 0xe2, 0xcb, 0xc6, 0x86, 0x08, 0x1f, 0xc3, 0x07,
	0x25, 0xac, 0x23, 0x17, 0x02, 0xc3, 0xb5, 0x82, 0x4b, 0x08, 0xfa, 0x02, 0x3a, 0xa7, 0xe1, 0xf2,
	0xdc, 0x65, 0x79, 0x2a, 0xc0, 0x29, 0x37, 0x6b, 0xa2, 0x92, 0x9b, 0x55, 0xb7, 0x75, 0x7e, 0x0d,
	0xbb, 0x45, 0x44, 0x05, 0xdd, 0x86, 0x8e, 0x90, 0x30, 0x98, 0x15, 0x15, 0x65, 0xa7, 0x43, 0x17,
	0x3a, 0xf7, 0xe0, 0x5a, 0xc1, 0x8d, 0x66, 0x43, 0xc6, 0x0f, 0x61, 0xb7, 0x88, 0xd5, 0xa4, 0x2f,
	0x11, 0x86, 0xfa, 0x12, 0x61, 0x89, 0xae, 0x52, 0xe1, 0xe1, 0x79, 0x03, 0xf9, 0x0c, 0x5a, 0x49,
	0x0e, 0xc8, 0x86, 0x46, 0xcc, 0x20, 0x44, 0xa0, 0x78, 0x58, 0x30, 0xf1, 0xbf, 0x95, 0xb8, 0x0d,
	0xa3, 0xbb, 0xd0, 0x64, 0x7f, 0x93, 0x77, 0x04, 0xe3, 0x2a, 0x28, 0x4a, 0xcc, 0x18, 0xe6, 0x7d,
	0xe5, 0x46, 0x47, 0x81, 0xff, 0x7a, 0xee, 0x4d, 0x28, 0x3f, 0xb1, 0x4d, 0xac, 0x8a, 0x58, 0xcd,
	0xbe, 0x72, 0xa3, 0x6f, 0x43, 0xf2, 0x46, 0xf2, 0xc1, 0x2a, 0xb7, 0xd1, 0x85, 0xe8, 0x73, 0x68,
	0x25, 0xcd, 0x42, 0x12, 0x8a, 0xab, 0x1a, 0x49, 0x6a, 0xfc, 0x1e, 0x8f, 0x59, 0x7d, 0x30, 0xe3,
	0x55, 0x3d, 0x23, 0x97, 0xfc, 0x12, 0xd2, 0xc6, 0xaa, 0x48, 0xb5, 0x60, 0x55, 0x6a, 0xe8, 0x16,
	0xac, 0xb2, 0xfb, 0x00, 0x6c, 0xd5, 0xac, 0xb5, 0x92, 0x90, 0xdf, 0x25, 0xda, 0x58, 0x91, 0xb0,
	0xca, 0x8b, 0x2f, 0xf1, 0x9a, 0xd5, 0xc1, 0xf1, 0xd0, 0x19, 0x41, 0x47, 0x6b, 0x6d, 0xec, 0x57,
	0x5c, 0x90, 0x4b, 0xd9, 0x4e, 0xd9, 0x27, 0xe3, 0x59, 0xd1, 0x85, 0xb7, 0x94, 0x55, 0xe4, 0xdf,
	0x6c, 0xd7, 0x84, 0x64, 0x39, 0x77, 0x27, 0x64, 0x1c, 0xc8, 0x7b, 0x5a, 0x2a, 0x18, 0xfe, 0x4c,
	0x7b, 0x6a, 0x44, 0x0d, 0x4e, 0x7d, 0xac, 0x2d, 0xd4, 0x82, 0x6d, 0xcc, 0x92, 0xb6, 0x8c, 0xe1,
	0x47, 0xe2, 0xa7, 0xf2, 0x07, 0xc4, 0x0e, 0xb4, 0x1e, 0xaf, 0x27, 0xf3, 0x55, 0xe4, 0xbd, 0x21,
	0xd6, 0x16, 0x02, 0xa8, 0xb3, 0xe6, 0x45, 0xa6, 0x96, 0x31, 0xbc, 0x0d, 0x90, 0xbe, 0x23, 0xa2,
	0x26, 0xd4, 0xd8, 0xc8, 0xda, 0x42, 0x6d, 0x68, 0x3e, 0x71, 0x23, 0xfa, 0xc4, 0xf5, 0xe6, 0x96,
	0x31, 0xbc, 0x95, 0xb6, 0x43, 0x66, 0xf3, 0x4d, 0xe0, 0x13, 0x11, 0xed, 0xd1, 0x25, 0x0b, 0x6c,
	0x0c, 0xff, 0x5a, 0x89, 0x6f, 0x9e, 0x4c, 0xcf, 0x02, 0x8b, 0x38, 0xa2, 0x67, 0x5b, 0x06, 0xea,
	0xaa, 0x17, 0x3a, 0xab, 0x82, 0x50, 0xf6, 0x82, 0x66, 0x55, 0x99, 0x4c, 0xc7, 0x17, 0xab, 0x86,
	0xcc, 0xe4, 0xf2, 0x65, 0x6d, 0xa3, 0xeb, 0x05, 0x57, 0x2a, 0xab, 0x8e, 0x7a, 0x60, 0xca, 0x47,
	0x4e, 0x3e, 0xa9, 0x81, 0x76, 0xa0, 0x23, 0x05, 0x32, 0x7e, 0x13, 0x5d, 0xcb, 0x5d, 0x76, 0xac,
	0x16, 0xb2, 0xf4, 0x2b, 0x8b, 0x05, 0x4c, 0xa2, 0x1e, 0x47, 0xcb, 0x64, 0x31, 0x73, 0x6d, 0xc3,
	0x6a, 0xa3, 0xbd, 0x22, 0xde, 0x6e, 0x75, 0x98, 0x79, 0x0e, 0xfe, 0xad, 0xee, 0x90, 0xc4, 0xcd,
	0x4d, 0xf8, 0xe3, 0x62, 0xb6, 0xd8, 0xc7, 0x3e, 0xcb, 0xc3, 0xda, 0x62, 0xfe, 0x14, 0xb1, 0xac,
	0x8b, 0x65, 0x28, 0xe6, 0x2f, 0x79, 0xe9, 0x46, 0xab, 0xc9, 0xc4, 0xaa, 0x28, 0xe2, 0x34, 0x9a,
	0x55, 0x7d, 0xf4, 0x9b, 0xef, 0xff, 0xb3, 0x6f, 0x7c, 0xf7, 0x6e, 0xdf, 0xf8, 0xfe, 0xdd, 0xbe,
	0xf1, 0xef, 0x77, 0xfb, 0xc6, 0x1f, 0xd4, 0x47, 0xee, 0x85, 0x4b, 0x43, 0x6f, 0x1d, 0x70, 0x62,
	0x12, 0x0f, 0x7c, 0x72, 0xb0, 0xbc, 0x98, 0x1d, 0x2c, 0xcf, 0x0e, 0x58, 0xa1, 0xce, 0xea, 0xfc,
	0x69, 0xfb, 0xde, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x8b, 0x43, 0x22, 0x1b, 0x2e, 0x17, 0x00,
	0x00,
}

func (m *LockOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LockOptions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LockOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.SnapShotTs.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if m.Sharding != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Sharding))
		i--
		dAtA[i] = 0x40
	}
	if m.Group != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Group))
		i--
		dAtA[i] = 0x38
	}
	if m.RetryWait != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.RetryWait))
		i--
		dAtA[i] = 0x30
	}
	if m.TableDefChanged {
		i--
		if m.TableDefChanged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.ForwardTo) > 0 {
		i -= len(m.ForwardTo)
		copy(dAtA[i:], m.ForwardTo)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ForwardTo)))
		i--
		dAtA[i] = 0x22
	}
	if m.Policy != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Policy))
		i--
		dAtA[i] = 0x18
	}
	if m.Mode != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Mode))
		i--
		dAtA[i] = 0x10
	}
	if m.Granularity != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Granularity))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LockTable) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LockTable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LockTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OriginTable != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.OriginTable))
		i--
		dAtA[i] = 0x38
	}
	if m.Sharding != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Sharding))
		i--
		dAtA[i] = 0x30
	}
	if m.Group != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Group))
		i--
		dAtA[i] = 0x28
	}
	if m.Valid {
		i--
		if m.Valid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Version != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0x12
	}
	if m.Table != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Table))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Request) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Request) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.RemainTxnInService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size, err := m.CanRestartService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	{
		size, err := m.SetRestartService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	{
		size, err := m.GetActiveTxn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	{
		size, err := m.CannotCommit.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	{
		size, err := m.ValidateService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size, err := m.KeepRemoteLock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	{
		size, err := m.KeepLockTableBind.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size, err := m.GetBind.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size, err := m.GetWaitingList.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size, err := m.GetTxnLock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size, err := m.Unlock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.Lock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Method != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Method))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.LockTable.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.RequestID != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.RequestID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Response) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Response) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.RemainTxnInService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size, err := m.CanRestartService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	{
		size, err := m.SetRestartService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x7a
	{
		size, err := m.GetActiveTxn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	{
		size, err := m.CannotCommit.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	{
		size, err := m.ValidateService.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	{
		size, err := m.KeepRemoteLock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size, err := m.KeepLockTableBind.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	{
		size, err := m.GetBind.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	{
		size, err := m.GetWaitingList.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size, err := m.GetTxnLock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size, err := m.Unlock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size, err := m.Lock.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.NewBind != nil {
		{
			size, err := m.NewBind.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLock(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintLock(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Method != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Method))
		i--
		dAtA[i] = 0x10
	}
	if m.RequestID != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.RequestID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LockRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LockRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Rows) > 0 {
		for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Rows[iNdEx])
			copy(dAtA[i:], m.Rows[iNdEx])
			i = encodeVarintLock(dAtA, i, uint64(len(m.Rows[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TxnID) > 0 {
		i -= len(m.TxnID)
		copy(dAtA[i:], m.TxnID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.TxnID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LockResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LockResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *GetTxnLockRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTxnLockRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTxnLockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Row) > 0 {
		i -= len(m.Row)
		copy(dAtA[i:], m.Row)
		i = encodeVarintLock(dAtA, i, uint64(len(m.Row)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TxnID) > 0 {
		i -= len(m.TxnID)
		copy(dAtA[i:], m.TxnID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.TxnID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetTxnLockResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetTxnLockResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTxnLockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.WaitingList) > 0 {
		for iNdEx := len(m.WaitingList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.WaitingList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Value != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetWaitingListRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetWaitingListRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetWaitingListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *GetWaitingListResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetWaitingListResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetWaitingListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.WaitingList) > 0 {
		for iNdEx := len(m.WaitingList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.WaitingList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *WaitTxn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *WaitTxn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WaitTxn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.CreatedOn) > 0 {
		i -= len(m.CreatedOn)
		copy(dAtA[i:], m.CreatedOn)
		i = encodeVarintLock(dAtA, i, uint64(len(m.CreatedOn)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TxnID) > 0 {
		i -= len(m.TxnID)
		copy(dAtA[i:], m.TxnID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.TxnID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnlockRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnlockRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Mutations) > 0 {
		for iNdEx := len(m.Mutations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Mutations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.CommitTS.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.TxnID) > 0 {
		i -= len(m.TxnID)
		copy(dAtA[i:], m.TxnID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.TxnID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UnlockResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UnlockResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnlockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *GetBindRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetBindRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetBindRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OriginTable != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.OriginTable))
		i--
		dAtA[i] = 0x28
	}
	if m.Sharding != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Sharding))
		i--
		dAtA[i] = 0x20
	}
	if m.Group != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Group))
		i--
		dAtA[i] = 0x18
	}
	if m.Table != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Table))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetBindResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetBindResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetBindResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.LockTable.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}

func (m *KeepLockTableBindRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KeepLockTableBindRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeepLockTableBindRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.LockTables) > 0 {
		for iNdEx := len(m.LockTables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LockTables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.TxnIDs) > 0 {
		for iNdEx := len(m.TxnIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.TxnIDs[iNdEx])
			copy(dAtA[i:], m.TxnIDs[iNdEx])
			i = encodeVarintLock(dAtA, i, uint64(len(m.TxnIDs[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Status != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *KeepLockTableBindResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KeepLockTableBindResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeepLockTableBindResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Status != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SetRestartServiceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetRestartServiceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetRestartServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SetRestartServiceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetRestartServiceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetRestartServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CanRestartServiceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CanRestartServiceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CanRestartServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CanRestartServiceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CanRestartServiceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CanRestartServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RemainTxnInServiceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemainTxnInServiceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemainTxnInServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemainTxnInServiceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemainTxnInServiceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemainTxnInServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RemainTxn != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.RemainTxn))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *KeepRemoteLockRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KeepRemoteLockRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeepRemoteLockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *KeepRemoteLockResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *KeepRemoteLockResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeepRemoteLockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ValidateServiceRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidateServiceRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidateServiceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidateServiceResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidateServiceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidateServiceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CannotCommitRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CannotCommitRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CannotCommitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.OrphanTxnList) > 0 {
		for iNdEx := len(m.OrphanTxnList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OrphanTxnList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLock(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *CannotCommitResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CannotCommitResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CannotCommitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.CommittingTxn) > 0 {
		for iNdEx := len(m.CommittingTxn) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.CommittingTxn[iNdEx])
			copy(dAtA[i:], m.CommittingTxn[iNdEx])
			i = encodeVarintLock(dAtA, i, uint64(len(m.CommittingTxn[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetActiveTxnRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetActiveTxnRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetActiveTxnRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceID) > 0 {
		i -= len(m.ServiceID)
		copy(dAtA[i:], m.ServiceID)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ServiceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetActiveTxnResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetActiveTxnResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetActiveTxnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Txn) > 0 {
		for iNdEx := len(m.Txn) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Txn[iNdEx])
			copy(dAtA[i:], m.Txn[iNdEx])
			i = encodeVarintLock(dAtA, i, uint64(len(m.Txn[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Valid {
		i--
		if m.Valid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OrphanTxn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OrphanTxn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OrphanTxn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Txn) > 0 {
		for iNdEx := len(m.Txn) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Txn[iNdEx])
			copy(dAtA[i:], m.Txn[iNdEx])
			i = encodeVarintLock(dAtA, i, uint64(len(m.Txn[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Service) > 0 {
		i -= len(m.Service)
		copy(dAtA[i:], m.Service)
		i = encodeVarintLock(dAtA, i, uint64(len(m.Service)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Result) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Result) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Result) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Waiters != 0 {
		i = encodeVarintLock(dAtA, i, uint64(m.Waiters))
		i--
		dAtA[i] = 0x48
	}
	if len(m.PrevWaiter) > 0 {
		i -= len(m.PrevWaiter)
		copy(dAtA[i:], m.PrevWaiter)
		i = encodeVarintLock(dAtA, i, uint64(len(m.PrevWaiter)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.ConflictTxn) > 0 {
		i -= len(m.ConflictTxn)
		copy(dAtA[i:], m.ConflictTxn)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ConflictTxn)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ConflictKey) > 0 {
		i -= len(m.ConflictKey)
		copy(dAtA[i:], m.ConflictKey)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ConflictKey)))
		i--
		dAtA[i] = 0x32
	}
	if m.TableDefChanged {
		i--
		if m.TableDefChanged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	{
		size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.HasPrevCommit {
		i--
		if m.HasPrevCommit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.HasConflict {
		i--
		if m.HasConflict {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.LockedOn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLock(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ExtraMutation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExtraMutation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExtraMutation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ReplaceTo) > 0 {
		i -= len(m.ReplaceTo)
		copy(dAtA[i:], m.ReplaceTo)
		i = encodeVarintLock(dAtA, i, uint64(len(m.ReplaceTo)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Skip {
		i--
		if m.Skip {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintLock(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintLock(dAtA []byte, offset int, v uint64) int {
	offset -= sovLock(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *LockOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Granularity != 0 {
		n += 1 + sovLock(uint64(m.Granularity))
	}
	if m.Mode != 0 {
		n += 1 + sovLock(uint64(m.Mode))
	}
	if m.Policy != 0 {
		n += 1 + sovLock(uint64(m.Policy))
	}
	l = len(m.ForwardTo)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.TableDefChanged {
		n += 2
	}
	if m.RetryWait != 0 {
		n += 1 + sovLock(uint64(m.RetryWait))
	}
	if m.Group != 0 {
		n += 1 + sovLock(uint64(m.Group))
	}
	if m.Sharding != 0 {
		n += 1 + sovLock(uint64(m.Sharding))
	}
	l = m.SnapShotTs.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LockTable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Table != 0 {
		n += 1 + sovLock(uint64(m.Table))
	}
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.Version != 0 {
		n += 1 + sovLock(uint64(m.Version))
	}
	if m.Valid {
		n += 2
	}
	if m.Group != 0 {
		n += 1 + sovLock(uint64(m.Group))
	}
	if m.Sharding != 0 {
		n += 1 + sovLock(uint64(m.Sharding))
	}
	if m.OriginTable != 0 {
		n += 1 + sovLock(uint64(m.OriginTable))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestID != 0 {
		n += 1 + sovLock(uint64(m.RequestID))
	}
	l = m.LockTable.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.Method != 0 {
		n += 1 + sovLock(uint64(m.Method))
	}
	l = m.Lock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.Unlock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetTxnLock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetWaitingList.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetBind.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.KeepLockTableBind.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.KeepRemoteLock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.ValidateService.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.CannotCommit.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetActiveTxn.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.SetRestartService.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.CanRestartService.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.RemainTxnInService.Size()
	n += 2 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Response) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestID != 0 {
		n += 1 + sovLock(uint64(m.RequestID))
	}
	if m.Method != 0 {
		n += 1 + sovLock(uint64(m.Method))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.NewBind != nil {
		l = m.NewBind.Size()
		n += 1 + l + sovLock(uint64(l))
	}
	l = m.Lock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.Unlock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetTxnLock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetWaitingList.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetBind.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.KeepLockTableBind.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.KeepRemoteLock.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.ValidateService.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.CannotCommit.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.GetActiveTxn.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.SetRestartService.Size()
	n += 1 + l + sovLock(uint64(l))
	l = m.CanRestartService.Size()
	n += 2 + l + sovLock(uint64(l))
	l = m.RemainTxnInService.Size()
	n += 2 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TxnID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if len(m.Rows) > 0 {
		for _, b := range m.Rows {
			l = len(b)
			n += 1 + l + sovLock(uint64(l))
		}
	}
	l = m.Options.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LockResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Result.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetTxnLockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TxnID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	l = len(m.Row)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetTxnLockResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 1 + sovLock(uint64(m.Value))
	}
	if len(m.WaitingList) > 0 {
		for _, e := range m.WaitingList {
			l = e.Size()
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetWaitingListRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Txn.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetWaitingListResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.WaitingList) > 0 {
		for _, e := range m.WaitingList {
			l = e.Size()
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WaitTxn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TxnID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	l = len(m.CreatedOn)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UnlockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TxnID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	l = m.CommitTS.Size()
	n += 1 + l + sovLock(uint64(l))
	if len(m.Mutations) > 0 {
		for _, e := range m.Mutations {
			l = e.Size()
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UnlockResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetBindRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.Table != 0 {
		n += 1 + sovLock(uint64(m.Table))
	}
	if m.Group != 0 {
		n += 1 + sovLock(uint64(m.Group))
	}
	if m.Sharding != 0 {
		n += 1 + sovLock(uint64(m.Sharding))
	}
	if m.OriginTable != 0 {
		n += 1 + sovLock(uint64(m.OriginTable))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetBindResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.LockTable.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *KeepLockTableBindRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovLock(uint64(m.Status))
	}
	if len(m.TxnIDs) > 0 {
		for _, b := range m.TxnIDs {
			l = len(b)
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if len(m.LockTables) > 0 {
		for _, e := range m.LockTables {
			l = e.Size()
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *KeepLockTableBindResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OK {
		n += 2
	}
	if m.Status != 0 {
		n += 1 + sovLock(uint64(m.Status))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetRestartServiceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetRestartServiceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OK {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CanRestartServiceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CanRestartServiceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OK {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RemainTxnInServiceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RemainTxnInServiceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RemainTxn != 0 {
		n += 1 + sovLock(uint64(m.RemainTxn))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *KeepRemoteLockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *KeepRemoteLockResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OK {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidateServiceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidateServiceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OK {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CannotCommitRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.OrphanTxnList) > 0 {
		for _, e := range m.OrphanTxnList {
			l = e.Size()
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CannotCommitResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.CommittingTxn) > 0 {
		for _, b := range m.CommittingTxn {
			l = len(b)
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetActiveTxnRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceID)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetActiveTxnResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Valid {
		n += 2
	}
	if len(m.Txn) > 0 {
		for _, b := range m.Txn {
			l = len(b)
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OrphanTxn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Service)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if len(m.Txn) > 0 {
		for _, b := range m.Txn {
			l = len(b)
			n += 1 + l + sovLock(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Result) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.LockedOn.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.HasConflict {
		n += 2
	}
	if m.HasPrevCommit {
		n += 2
	}
	l = m.Timestamp.Size()
	n += 1 + l + sovLock(uint64(l))
	if m.TableDefChanged {
		n += 2
	}
	l = len(m.ConflictKey)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	l = len(m.ConflictTxn)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	l = len(m.PrevWaiter)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.Waiters != 0 {
		n += 1 + sovLock(uint64(m.Waiters))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExtraMutation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.Skip {
		n += 2
	}
	l = len(m.ReplaceTo)
	if l > 0 {
		n += 1 + l + sovLock(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovLock(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLock(x uint64) (n int) {
	return sovLock(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *LockOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LockOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LockOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Granularity", wireType)
			}
			m.Granularity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Granularity |= Granularity(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= LockMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType)
			}
			m.Policy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Policy |= WaitPolicy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForwardTo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ForwardTo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableDefChanged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TableDefChanged = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetryWait", wireType)
			}
			m.RetryWait = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RetryWait |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			m.Group = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Group |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sharding", wireType)
			}
			m.Sharding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sharding |= Sharding(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SnapShotTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SnapShotTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LockTable) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LockTable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LockTable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			m.Table = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Table |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Valid = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			m.Group = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Group |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sharding", wireType)
			}
			m.Sharding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sharding |= Sharding(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginTable", wireType)
			}
			m.OriginTable = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OriginTable |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Request) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType)
			}
			m.RequestID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockTable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LockTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			m.Method = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Method |= Method(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Unlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetTxnLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetTxnLock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetWaitingList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetWaitingList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetBind", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetBind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepLockTableBind", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KeepLockTableBind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepRemoteLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KeepRemoteLock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidateService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ValidateService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CannotCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CannotCommit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetActiveTxn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetActiveTxn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetRestartService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SetRestartService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanRestartService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CanRestartService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemainTxnInService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RemainTxnInService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestID", wireType)
			}
			m.RequestID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			m.Method = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Method |= Method(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = append(m.Error[:0], dAtA[iNdEx:postIndex]...)
			if m.Error == nil {
				m.Error = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewBind", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NewBind == nil {
				m.NewBind = &LockTable{}
			}
			if err := m.NewBind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Lock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Unlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetTxnLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetTxnLock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetWaitingList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetWaitingList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetBind", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetBind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepLockTableBind", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KeepLockTableBind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepRemoteLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.KeepRemoteLock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidateService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ValidateService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CannotCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CannotCommit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetActiveTxn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GetActiveTxn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetRestartService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SetRestartService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanRestartService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CanRestartService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemainTxnInService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RemainTxnInService.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LockRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnID = append(m.TxnID[:0], dAtA[iNdEx:postIndex]...)
			if m.TxnID == nil {
				m.TxnID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Rows = append(m.Rows, make([]byte, postIndex-iNdEx))
			copy(m.Rows[len(m.Rows)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LockResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LockResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTxnLockRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetTxnLockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTxnLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnID = append(m.TxnID[:0], dAtA[iNdEx:postIndex]...)
			if m.TxnID == nil {
				m.TxnID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Row", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Row = append(m.Row[:0], dAtA[iNdEx:postIndex]...)
			if m.Row == nil {
				m.Row = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetTxnLockResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetTxnLockResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTxnLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WaitingList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WaitingList = append(m.WaitingList, WaitTxn{})
			if err := m.WaitingList[len(m.WaitingList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetWaitingListRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetWaitingListRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetWaitingListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Txn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetWaitingListResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetWaitingListResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetWaitingListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WaitingList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WaitingList = append(m.WaitingList, WaitTxn{})
			if err := m.WaitingList[len(m.WaitingList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WaitTxn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WaitTxn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WaitTxn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnID = append(m.TxnID[:0], dAtA[iNdEx:postIndex]...)
			if m.TxnID == nil {
				m.TxnID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedOn", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreatedOn = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnlockRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UnlockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnlockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnID = append(m.TxnID[:0], dAtA[iNdEx:postIndex]...)
			if m.TxnID == nil {
				m.TxnID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitTS", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CommitTS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mutations = append(m.Mutations, ExtraMutation{})
			if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnlockResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UnlockResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnlockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetBindRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetBindRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBindRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			m.Table = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Table |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
			}
			m.Group = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Group |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sharding", wireType)
			}
			m.Sharding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sharding |= Sharding(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginTable", wireType)
			}
			m.OriginTable = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OriginTable |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetBindResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetBindResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetBindResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockTable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LockTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeepLockTableBindRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KeepLockTableBindRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeepLockTableBindRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnIDs", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnIDs = append(m.TxnIDs, make([]byte, postIndex-iNdEx))
			copy(m.TxnIDs[len(m.TxnIDs)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockTables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LockTables = append(m.LockTables, LockTable{})
			if err := m.LockTables[len(m.LockTables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeepLockTableBindResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KeepLockTableBindResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeepLockTableBindResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetRestartServiceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetRestartServiceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetRestartServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetRestartServiceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetRestartServiceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetRestartServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CanRestartServiceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CanRestartServiceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CanRestartServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CanRestartServiceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CanRestartServiceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CanRestartServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemainTxnInServiceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemainTxnInServiceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemainTxnInServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemainTxnInServiceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemainTxnInServiceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemainTxnInServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemainTxn", wireType)
			}
			m.RemainTxn = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RemainTxn |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeepRemoteLockRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KeepRemoteLockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeepRemoteLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeepRemoteLockResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KeepRemoteLockResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeepRemoteLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidateServiceRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidateServiceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidateServiceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidateServiceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidateServiceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidateServiceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CannotCommitRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CannotCommitRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CannotCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrphanTxnList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrphanTxnList = append(m.OrphanTxnList, OrphanTxn{})
			if err := m.OrphanTxnList[len(m.OrphanTxnList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CannotCommitResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CannotCommitResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CannotCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittingTxn", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommittingTxn = append(m.CommittingTxn, make([]byte, postIndex-iNdEx))
			copy(m.CommittingTxn[len(m.CommittingTxn)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetActiveTxnRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetActiveTxnRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetActiveTxnRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetActiveTxnResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetActiveTxnResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetActiveTxnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Valid = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Txn = append(m.Txn, make([]byte, postIndex-iNdEx))
			copy(m.Txn[len(m.Txn)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OrphanTxn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OrphanTxn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OrphanTxn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Service = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Txn = append(m.Txn, make([]byte, postIndex-iNdEx))
			copy(m.Txn[len(m.Txn)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Result) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Result: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockedOn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LockedOn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasConflict", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasConflict = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasPrevCommit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasPrevCommit = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableDefChanged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TableDefChanged = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConflictKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConflictKey = append(m.ConflictKey[:0], dAtA[iNdEx:postIndex]...)
			if m.ConflictKey == nil {
				m.ConflictKey = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConflictTxn", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConflictTxn = append(m.ConflictTxn[:0], dAtA[iNdEx:postIndex]...)
			if m.ConflictTxn == nil {
				m.ConflictTxn = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevWaiter", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevWaiter = append(m.PrevWaiter[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevWaiter == nil {
				m.PrevWaiter = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Waiters", wireType)
			}
			m.Waiters = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Waiters |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExtraMutation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowLock
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExtraMutation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExtraMutation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Skip", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Skip = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplaceTo", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLock
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLock
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLock
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReplaceTo = append(m.ReplaceTo[:0], dAtA[iNdEx:postIndex]...)
			if m.ReplaceTo == nil {
				m.ReplaceTo = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLock(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLock
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLock(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowLock
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLock
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLock
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthLock
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLock
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLock
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLock        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLock          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLock = fmt.Errorf("proto: unexpected end of group")
)