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

package cdcpb

import (
	"fmt"
	"io"
	"math"

	proto "github.com/golang/protobuf/proto"

	_ "github.com/gogo/protobuf/gogoproto"

	errorpb "github.com/pingcap/kvproto/pkg/errorpb"

	kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb"

	metapb "github.com/pingcap/kvproto/pkg/metapb"

	raft_cmdpb "github.com/pingcap/kvproto/pkg/raft_cmdpb"

	context "golang.org/x/net/context"

	grpc "google.golang.org/grpc"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

type Event_LogType int32

const (
	Event_UNKNOWN     Event_LogType = 0
	Event_PREWRITE    Event_LogType = 1
	Event_COMMIT      Event_LogType = 2
	Event_ROLLBACK    Event_LogType = 3
	Event_COMMITTED   Event_LogType = 4
	Event_INITIALIZED Event_LogType = 5
)

var Event_LogType_name = map[int32]string{
	0: "UNKNOWN",
	1: "PREWRITE",
	2: "COMMIT",
	3: "ROLLBACK",
	4: "COMMITTED",
	5: "INITIALIZED",
}
var Event_LogType_value = map[string]int32{
	"UNKNOWN":     0,
	"PREWRITE":    1,
	"COMMIT":      2,
	"ROLLBACK":    3,
	"COMMITTED":   4,
	"INITIALIZED": 5,
}

func (x Event_LogType) String() string {
	return proto.EnumName(Event_LogType_name, int32(x))
}
func (Event_LogType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 0}
}

type Event_Row_OpType int32

const (
	Event_Row_UNKNOWN Event_Row_OpType = 0
	Event_Row_PUT     Event_Row_OpType = 1
	Event_Row_DELETE  Event_Row_OpType = 2
)

var Event_Row_OpType_name = map[int32]string{
	0: "UNKNOWN",
	1: "PUT",
	2: "DELETE",
}
var Event_Row_OpType_value = map[string]int32{
	"UNKNOWN": 0,
	"PUT":     1,
	"DELETE":  2,
}

func (x Event_Row_OpType) String() string {
	return proto.EnumName(Event_Row_OpType_name, int32(x))
}
func (Event_Row_OpType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{7, 0, 0}
}

// KvAPI specifies to capture data written by different KV API.
// See more details in https://github.com/tikv/rfcs/blob/master/text/0069-api-v2.md.
type ChangeDataRequest_KvAPI int32

const (
	ChangeDataRequest_TiBD  ChangeDataRequest_KvAPI = 0
	ChangeDataRequest_RawKV ChangeDataRequest_KvAPI = 1
	ChangeDataRequest_TxnKV ChangeDataRequest_KvAPI = 2
)

var ChangeDataRequest_KvAPI_name = map[int32]string{
	0: "TiBD",
	1: "RawKV",
	2: "TxnKV",
}
var ChangeDataRequest_KvAPI_value = map[string]int32{
	"TiBD":  0,
	"RawKV": 1,
	"TxnKV": 2,
}

func (x ChangeDataRequest_KvAPI) String() string {
	return proto.EnumName(ChangeDataRequest_KvAPI_name, int32(x))
}
func (ChangeDataRequest_KvAPI) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cdcpb_1c68e3d6625138c3, []int{10, 0}
}

type Header struct {
	ClusterId            uint64   `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	TicdcVersion         string   `protobuf:"bytes,2,opt,name=ticdc_version,json=ticdcVersion,proto3" json:"ticdc_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Header proto.InternalMessageInfo

func (m *Header) GetClusterId() uint64 {
	if m != nil {
		return m.ClusterId
	}
	return 0
}

func (m *Header) GetTicdcVersion() string {
	if m != nil {
		return m.TicdcVersion
	}
	return ""
}

type DuplicateRequest struct {
	RegionId             uint64   `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DuplicateRequest proto.InternalMessageInfo

func (m *DuplicateRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

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

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

var xxx_messageInfo_Compatibility proto.InternalMessageInfo

func (m *Compatibility) GetRequiredVersion() string {
	if m != nil {
		return m.RequiredVersion
	}
	return ""
}

// ClusterIDMismatch is an error variable that
// tells people that the cluster ID of the request does not match the TiKV cluster ID.
type ClusterIDMismatch struct {
	// The current tikv cluster ID.
	Current uint64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"`
	// The cluster ID of the TiCDC request.
	Request              uint64   `protobuf:"varint,2,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ClusterIDMismatch proto.InternalMessageInfo

func (m *ClusterIDMismatch) GetCurrent() uint64 {
	if m != nil {
		return m.Current
	}
	return 0
}

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

type Error struct {
	NotLeader            *errorpb.NotLeader      `protobuf:"bytes,1,opt,name=not_leader,json=notLeader" json:"not_leader,omitempty"`
	RegionNotFound       *errorpb.RegionNotFound `protobuf:"bytes,2,opt,name=region_not_found,json=regionNotFound" json:"region_not_found,omitempty"`
	EpochNotMatch        *errorpb.EpochNotMatch  `protobuf:"bytes,3,opt,name=epoch_not_match,json=epochNotMatch" json:"epoch_not_match,omitempty"`
	DuplicateRequest     *DuplicateRequest       `protobuf:"bytes,4,opt,name=duplicate_request,json=duplicateRequest" json:"duplicate_request,omitempty"`
	Compatibility        *Compatibility          `protobuf:"bytes,5,opt,name=compatibility" json:"compatibility,omitempty"`
	ClusterIdMismatch    *ClusterIDMismatch      `protobuf:"bytes,6,opt,name=cluster_id_mismatch,json=clusterIdMismatch" json:"cluster_id_mismatch,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetNotLeader() *errorpb.NotLeader {
	if m != nil {
		return m.NotLeader
	}
	return nil
}

func (m *Error) GetRegionNotFound() *errorpb.RegionNotFound {
	if m != nil {
		return m.RegionNotFound
	}
	return nil
}

func (m *Error) GetEpochNotMatch() *errorpb.EpochNotMatch {
	if m != nil {
		return m.EpochNotMatch
	}
	return nil
}

func (m *Error) GetDuplicateRequest() *DuplicateRequest {
	if m != nil {
		return m.DuplicateRequest
	}
	return nil
}

func (m *Error) GetCompatibility() *Compatibility {
	if m != nil {
		return m.Compatibility
	}
	return nil
}

func (m *Error) GetClusterIdMismatch() *ClusterIDMismatch {
	if m != nil {
		return m.ClusterIdMismatch
	}
	return nil
}

type TxnInfo struct {
	StartTs              uint64   `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
	Primary              []byte   `protobuf:"bytes,2,opt,name=primary,proto3" json:"primary,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnInfo proto.InternalMessageInfo

func (m *TxnInfo) GetStartTs() uint64 {
	if m != nil {
		return m.StartTs
	}
	return 0
}

func (m *TxnInfo) GetPrimary() []byte {
	if m != nil {
		return m.Primary
	}
	return nil
}

type TxnStatus struct {
	StartTs              uint64   `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
	MinCommitTs          uint64   `protobuf:"varint,2,opt,name=min_commit_ts,json=minCommitTs,proto3" json:"min_commit_ts,omitempty"`
	CommitTs             uint64   `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"`
	IsRolledBack         bool     `protobuf:"varint,4,opt,name=is_rolled_back,json=isRolledBack,proto3" json:"is_rolled_back,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxnStatus proto.InternalMessageInfo

func (m *TxnStatus) GetStartTs() uint64 {
	if m != nil {
		return m.StartTs
	}
	return 0
}

func (m *TxnStatus) GetMinCommitTs() uint64 {
	if m != nil {
		return m.MinCommitTs
	}
	return 0
}

func (m *TxnStatus) GetCommitTs() uint64 {
	if m != nil {
		return m.CommitTs
	}
	return 0
}

func (m *TxnStatus) GetIsRolledBack() bool {
	if m != nil {
		return m.IsRolledBack
	}
	return false
}

type Event struct {
	RegionId  uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	Index     uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	RequestId uint64 `protobuf:"varint,7,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Types that are valid to be assigned to Event:
	//	*Event_Entries_
	//	*Event_Admin_
	//	*Event_Error
	//	*Event_ResolvedTs
	//	*Event_LongTxn_
	Event                isEvent_Event `protobuf_oneof:"event"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Event proto.InternalMessageInfo

type isEvent_Event interface {
	isEvent_Event()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Event_Entries_ struct {
	Entries *Event_Entries `protobuf:"bytes,3,opt,name=entries,oneof"`
}
type Event_Admin_ struct {
	Admin *Event_Admin `protobuf:"bytes,4,opt,name=admin,oneof"`
}
type Event_Error struct {
	Error *Error `protobuf:"bytes,5,opt,name=error,oneof"`
}
type Event_ResolvedTs struct {
	ResolvedTs uint64 `protobuf:"varint,6,opt,name=resolved_ts,json=resolvedTs,proto3,oneof"`
}
type Event_LongTxn_ struct {
	LongTxn *Event_LongTxn `protobuf:"bytes,8,opt,name=long_txn,json=longTxn,oneof"`
}

func (*Event_Entries_) isEvent_Event()   {}
func (*Event_Admin_) isEvent_Event()     {}
func (*Event_Error) isEvent_Event()      {}
func (*Event_ResolvedTs) isEvent_Event() {}
func (*Event_LongTxn_) isEvent_Event()   {}

func (m *Event) GetEvent() isEvent_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *Event) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

func (m *Event) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *Event) GetRequestId() uint64 {
	if m != nil {
		return m.RequestId
	}
	return 0
}

func (m *Event) GetEntries() *Event_Entries {
	if x, ok := m.GetEvent().(*Event_Entries_); ok {
		return x.Entries
	}
	return nil
}

func (m *Event) GetAdmin() *Event_Admin {
	if x, ok := m.GetEvent().(*Event_Admin_); ok {
		return x.Admin
	}
	return nil
}

func (m *Event) GetError() *Error {
	if x, ok := m.GetEvent().(*Event_Error); ok {
		return x.Error
	}
	return nil
}

// Deprecated: Do not use.
func (m *Event) GetResolvedTs() uint64 {
	if x, ok := m.GetEvent().(*Event_ResolvedTs); ok {
		return x.ResolvedTs
	}
	return 0
}

func (m *Event) GetLongTxn() *Event_LongTxn {
	if x, ok := m.GetEvent().(*Event_LongTxn_); ok {
		return x.LongTxn
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Event) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Event_OneofMarshaler, _Event_OneofUnmarshaler, _Event_OneofSizer, []interface{}{
		(*Event_Entries_)(nil),
		(*Event_Admin_)(nil),
		(*Event_Error)(nil),
		(*Event_ResolvedTs)(nil),
		(*Event_LongTxn_)(nil),
	}
}

func _Event_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Event)
	// event
	switch x := m.Event.(type) {
	case *Event_Entries_:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Entries); err != nil {
			return err
		}
	case *Event_Admin_:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Admin); err != nil {
			return err
		}
	case *Event_Error:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *Event_ResolvedTs:
		_ = b.EncodeVarint(6<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.ResolvedTs))
	case *Event_LongTxn_:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LongTxn); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Event.Event has unexpected type %T", x)
	}
	return nil
}

func _Event_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Event)
	switch tag {
	case 3: // event.entries
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Event_Entries)
		err := b.DecodeMessage(msg)
		m.Event = &Event_Entries_{msg}
		return true, err
	case 4: // event.admin
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Event_Admin)
		err := b.DecodeMessage(msg)
		m.Event = &Event_Admin_{msg}
		return true, err
	case 5: // event.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Error)
		err := b.DecodeMessage(msg)
		m.Event = &Event_Error{msg}
		return true, err
	case 6: // event.resolved_ts
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Event = &Event_ResolvedTs{x}
		return true, err
	case 8: // event.long_txn
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Event_LongTxn)
		err := b.DecodeMessage(msg)
		m.Event = &Event_LongTxn_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Event_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Event)
	// event
	switch x := m.Event.(type) {
	case *Event_Entries_:
		s := proto.Size(x.Entries)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Event_Admin_:
		s := proto.Size(x.Admin)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Event_Error:
		s := proto.Size(x.Error)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Event_ResolvedTs:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.ResolvedTs))
	case *Event_LongTxn_:
		s := proto.Size(x.LongTxn)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Event_Row struct {
	StartTs              uint64           `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"`
	CommitTs             uint64           `protobuf:"varint,2,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"`
	Type                 Event_LogType    `protobuf:"varint,3,opt,name=type,proto3,enum=cdcpb.Event_LogType" json:"type,omitempty"`
	OpType               Event_Row_OpType `protobuf:"varint,4,opt,name=op_type,json=opType,proto3,enum=cdcpb.Event_Row_OpType" json:"op_type,omitempty"`
	Key                  []byte           `protobuf:"bytes,5,opt,name=key,proto3" json:"key,omitempty"`
	Value                []byte           `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"`
	OldValue             []byte           `protobuf:"bytes,7,opt,name=old_value,json=oldValue,proto3" json:"old_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_Event_Row proto.InternalMessageInfo

func (m *Event_Row) GetStartTs() uint64 {
	if m != nil {
		return m.StartTs
	}
	return 0
}

func (m *Event_Row) GetCommitTs() uint64 {
	if m != nil {
		return m.CommitTs
	}
	return 0
}

func (m *Event_Row) GetType() Event_LogType {
	if m != nil {
		return m.Type
	}
	return Event_UNKNOWN
}

func (m *Event_Row) GetOpType() Event_Row_OpType {
	if m != nil {
		return m.OpType
	}
	return Event_Row_UNKNOWN
}

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

func (m *Event_Row) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Event_Row) GetOldValue() []byte {
	if m != nil {
		return m.OldValue
	}
	return nil
}

type Event_Entries struct {
	Entries              []*Event_Row `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_Event_Entries proto.InternalMessageInfo

func (m *Event_Entries) GetEntries() []*Event_Row {
	if m != nil {
		return m.Entries
	}
	return nil
}

type Event_Admin struct {
	AdminRequest         *raft_cmdpb.AdminRequest  `protobuf:"bytes,1,opt,name=admin_request,json=adminRequest" json:"admin_request,omitempty"`
	AdminResponse        *raft_cmdpb.AdminResponse `protobuf:"bytes,2,opt,name=admin_response,json=adminResponse" json:"admin_response,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_Event_Admin proto.InternalMessageInfo

func (m *Event_Admin) GetAdminRequest() *raft_cmdpb.AdminRequest {
	if m != nil {
		return m.AdminRequest
	}
	return nil
}

func (m *Event_Admin) GetAdminResponse() *raft_cmdpb.AdminResponse {
	if m != nil {
		return m.AdminResponse
	}
	return nil
}

type Event_LongTxn struct {
	TxnInfo              []*TxnInfo `protobuf:"bytes,1,rep,name=txn_info,json=txnInfo" json:"txn_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_Event_LongTxn proto.InternalMessageInfo

func (m *Event_LongTxn) GetTxnInfo() []*TxnInfo {
	if m != nil {
		return m.TxnInfo
	}
	return nil
}

type ChangeDataEvent struct {
	Events               []*Event    `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"`
	ResolvedTs           *ResolvedTs `protobuf:"bytes,2,opt,name=resolved_ts,json=resolvedTs" json:"resolved_ts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_ChangeDataEvent proto.InternalMessageInfo

func (m *ChangeDataEvent) GetEvents() []*Event {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *ChangeDataEvent) GetResolvedTs() *ResolvedTs {
	if m != nil {
		return m.ResolvedTs
	}
	return nil
}

type ResolvedTs struct {
	Regions              []uint64 `protobuf:"varint,1,rep,packed,name=regions" json:"regions,omitempty"`
	Ts                   uint64   `protobuf:"varint,2,opt,name=ts,proto3" json:"ts,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ResolvedTs proto.InternalMessageInfo

func (m *ResolvedTs) GetRegions() []uint64 {
	if m != nil {
		return m.Regions
	}
	return nil
}

func (m *ResolvedTs) GetTs() uint64 {
	if m != nil {
		return m.Ts
	}
	return 0
}

type ChangeDataRequest struct {
	Header       *Header             `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	RegionId     uint64              `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	RegionEpoch  *metapb.RegionEpoch `protobuf:"bytes,3,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"`
	CheckpointTs uint64              `protobuf:"varint,4,opt,name=checkpoint_ts,json=checkpointTs,proto3" json:"checkpoint_ts,omitempty"`
	StartKey     []byte              `protobuf:"bytes,5,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
	EndKey       []byte              `protobuf:"bytes,6,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
	// Used for CDC to identify events corresponding to different requests.
	RequestId uint64          `protobuf:"varint,7,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	ExtraOp   kvrpcpb.ExtraOp `protobuf:"varint,8,opt,name=extra_op,json=extraOp,proto3,enum=kvrpcpb.ExtraOp" json:"extra_op,omitempty"`
	// Types that are valid to be assigned to Request:
	//	*ChangeDataRequest_Register_
	//	*ChangeDataRequest_NotifyTxnStatus_
	Request              isChangeDataRequest_Request `protobuf_oneof:"request"`
	KvApi                ChangeDataRequest_KvAPI     `protobuf:"varint,11,opt,name=kv_api,json=kvApi,proto3,enum=cdcpb.ChangeDataRequest_KvAPI" json:"kv_api,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_ChangeDataRequest proto.InternalMessageInfo

type isChangeDataRequest_Request interface {
	isChangeDataRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type ChangeDataRequest_Register_ struct {
	Register *ChangeDataRequest_Register `protobuf:"bytes,9,opt,name=register,oneof"`
}
type ChangeDataRequest_NotifyTxnStatus_ struct {
	NotifyTxnStatus *ChangeDataRequest_NotifyTxnStatus `protobuf:"bytes,10,opt,name=notify_txn_status,json=notifyTxnStatus,oneof"`
}

func (*ChangeDataRequest_Register_) isChangeDataRequest_Request()        {}
func (*ChangeDataRequest_NotifyTxnStatus_) isChangeDataRequest_Request() {}

func (m *ChangeDataRequest) GetRequest() isChangeDataRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *ChangeDataRequest) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *ChangeDataRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

func (m *ChangeDataRequest) GetRegionEpoch() *metapb.RegionEpoch {
	if m != nil {
		return m.RegionEpoch
	}
	return nil
}

func (m *ChangeDataRequest) GetCheckpointTs() uint64 {
	if m != nil {
		return m.CheckpointTs
	}
	return 0
}

func (m *ChangeDataRequest) GetStartKey() []byte {
	if m != nil {
		return m.StartKey
	}
	return nil
}

func (m *ChangeDataRequest) GetEndKey() []byte {
	if m != nil {
		return m.EndKey
	}
	return nil
}

func (m *ChangeDataRequest) GetRequestId() uint64 {
	if m != nil {
		return m.RequestId
	}
	return 0
}

func (m *ChangeDataRequest) GetExtraOp() kvrpcpb.ExtraOp {
	if m != nil {
		return m.ExtraOp
	}
	return kvrpcpb.ExtraOp_Noop
}

func (m *ChangeDataRequest) GetRegister() *ChangeDataRequest_Register {
	if x, ok := m.GetRequest().(*ChangeDataRequest_Register_); ok {
		return x.Register
	}
	return nil
}

func (m *ChangeDataRequest) GetNotifyTxnStatus() *ChangeDataRequest_NotifyTxnStatus {
	if x, ok := m.GetRequest().(*ChangeDataRequest_NotifyTxnStatus_); ok {
		return x.NotifyTxnStatus
	}
	return nil
}

func (m *ChangeDataRequest) GetKvApi() ChangeDataRequest_KvAPI {
	if m != nil {
		return m.KvApi
	}
	return ChangeDataRequest_TiBD
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ChangeDataRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ChangeDataRequest_OneofMarshaler, _ChangeDataRequest_OneofUnmarshaler, _ChangeDataRequest_OneofSizer, []interface{}{
		(*ChangeDataRequest_Register_)(nil),
		(*ChangeDataRequest_NotifyTxnStatus_)(nil),
	}
}

func _ChangeDataRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ChangeDataRequest)
	// request
	switch x := m.Request.(type) {
	case *ChangeDataRequest_Register_:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Register); err != nil {
			return err
		}
	case *ChangeDataRequest_NotifyTxnStatus_:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NotifyTxnStatus); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ChangeDataRequest.Request has unexpected type %T", x)
	}
	return nil
}

func _ChangeDataRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ChangeDataRequest)
	switch tag {
	case 9: // request.register
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChangeDataRequest_Register)
		err := b.DecodeMessage(msg)
		m.Request = &ChangeDataRequest_Register_{msg}
		return true, err
	case 10: // request.notify_txn_status
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ChangeDataRequest_NotifyTxnStatus)
		err := b.DecodeMessage(msg)
		m.Request = &ChangeDataRequest_NotifyTxnStatus_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ChangeDataRequest_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ChangeDataRequest)
	// request
	switch x := m.Request.(type) {
	case *ChangeDataRequest_Register_:
		s := proto.Size(x.Register)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ChangeDataRequest_NotifyTxnStatus_:
		s := proto.Size(x.NotifyTxnStatus)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ChangeDataRequest_Register struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ChangeDataRequest_Register proto.InternalMessageInfo

type ChangeDataRequest_NotifyTxnStatus struct {
	TxnStatus            []*TxnStatus `protobuf:"bytes,1,rep,name=txn_status,json=txnStatus" json:"txn_status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_ChangeDataRequest_NotifyTxnStatus proto.InternalMessageInfo

func (m *ChangeDataRequest_NotifyTxnStatus) GetTxnStatus() []*TxnStatus {
	if m != nil {
		return m.TxnStatus
	}
	return nil
}

func init() {
	proto.RegisterType((*Header)(nil), "cdcpb.Header")
	proto.RegisterType((*DuplicateRequest)(nil), "cdcpb.DuplicateRequest")
	proto.RegisterType((*Compatibility)(nil), "cdcpb.Compatibility")
	proto.RegisterType((*ClusterIDMismatch)(nil), "cdcpb.ClusterIDMismatch")
	proto.RegisterType((*Error)(nil), "cdcpb.Error")
	proto.RegisterType((*TxnInfo)(nil), "cdcpb.TxnInfo")
	proto.RegisterType((*TxnStatus)(nil), "cdcpb.TxnStatus")
	proto.RegisterType((*Event)(nil), "cdcpb.Event")
	proto.RegisterType((*Event_Row)(nil), "cdcpb.Event.Row")
	proto.RegisterType((*Event_Entries)(nil), "cdcpb.Event.Entries")
	proto.RegisterType((*Event_Admin)(nil), "cdcpb.Event.Admin")
	proto.RegisterType((*Event_LongTxn)(nil), "cdcpb.Event.LongTxn")
	proto.RegisterType((*ChangeDataEvent)(nil), "cdcpb.ChangeDataEvent")
	proto.RegisterType((*ResolvedTs)(nil), "cdcpb.ResolvedTs")
	proto.RegisterType((*ChangeDataRequest)(nil), "cdcpb.ChangeDataRequest")
	proto.RegisterType((*ChangeDataRequest_Register)(nil), "cdcpb.ChangeDataRequest.Register")
	proto.RegisterType((*ChangeDataRequest_NotifyTxnStatus)(nil), "cdcpb.ChangeDataRequest.NotifyTxnStatus")
	proto.RegisterEnum("cdcpb.Event_LogType", Event_LogType_name, Event_LogType_value)
	proto.RegisterEnum("cdcpb.Event_Row_OpType", Event_Row_OpType_name, Event_Row_OpType_value)
	proto.RegisterEnum("cdcpb.ChangeDataRequest_KvAPI", ChangeDataRequest_KvAPI_name, ChangeDataRequest_KvAPI_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for ChangeData service

type ChangeDataClient interface {
	EventFeed(ctx context.Context, opts ...grpc.CallOption) (ChangeData_EventFeedClient, error)
}

type changeDataClient struct {
	cc *grpc.ClientConn
}

func NewChangeDataClient(cc *grpc.ClientConn) ChangeDataClient {
	return &changeDataClient{cc}
}

func (c *changeDataClient) EventFeed(ctx context.Context, opts ...grpc.CallOption) (ChangeData_EventFeedClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ChangeData_serviceDesc.Streams[0], "/cdcpb.ChangeData/EventFeed", opts...)
	if err != nil {
		return nil, err
	}
	x := &changeDataEventFeedClient{stream}
	return x, nil
}

type ChangeData_EventFeedClient interface {
	Send(*ChangeDataRequest) error
	Recv() (*ChangeDataEvent, error)
	grpc.ClientStream
}

type changeDataEventFeedClient struct {
	grpc.ClientStream
}

func (x *changeDataEventFeedClient) Send(m *ChangeDataRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *changeDataEventFeedClient) Recv() (*ChangeDataEvent, error) {
	m := new(ChangeDataEvent)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for ChangeData service

type ChangeDataServer interface {
	EventFeed(ChangeData_EventFeedServer) error
}

func RegisterChangeDataServer(s *grpc.Server, srv ChangeDataServer) {
	s.RegisterService(&_ChangeData_serviceDesc, srv)
}

func _ChangeData_EventFeed_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ChangeDataServer).EventFeed(&changeDataEventFeedServer{stream})
}

type ChangeData_EventFeedServer interface {
	Send(*ChangeDataEvent) error
	Recv() (*ChangeDataRequest, error)
	grpc.ServerStream
}

type changeDataEventFeedServer struct {
	grpc.ServerStream
}

func (x *changeDataEventFeedServer) Send(m *ChangeDataEvent) error {
	return x.ServerStream.SendMsg(m)
}

func (x *changeDataEventFeedServer) Recv() (*ChangeDataRequest, error) {
	m := new(ChangeDataRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _ChangeData_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cdcpb.ChangeData",
	HandlerType: (*ChangeDataServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "EventFeed",
			Handler:       _ChangeData_EventFeed_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "cdcpb.proto",
}

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

func (m *Header) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ClusterId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.ClusterId))
	}
	if len(m.TicdcVersion) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.TicdcVersion)))
		i += copy(dAtA[i:], m.TicdcVersion)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *DuplicateRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RegionId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Compatibility) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RequiredVersion) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.RequiredVersion)))
		i += copy(dAtA[i:], m.RequiredVersion)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ClusterIDMismatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Current != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Current))
	}
	if m.Request != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Request))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Error) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NotLeader != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.NotLeader.Size()))
		n1, err := m.NotLeader.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.RegionNotFound != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionNotFound.Size()))
		n2, err := m.RegionNotFound.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.EpochNotMatch != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.EpochNotMatch.Size()))
		n3, err := m.EpochNotMatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.DuplicateRequest != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.DuplicateRequest.Size()))
		n4, err := m.DuplicateRequest.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.Compatibility != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Compatibility.Size()))
		n5, err := m.Compatibility.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.ClusterIdMismatch != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.ClusterIdMismatch.Size()))
		n6, err := m.ClusterIdMismatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *TxnInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StartTs != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.StartTs))
	}
	if len(m.Primary) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.Primary)))
		i += copy(dAtA[i:], m.Primary)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *TxnStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StartTs != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.StartTs))
	}
	if m.MinCommitTs != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.MinCommitTs))
	}
	if m.CommitTs != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.CommitTs))
	}
	if m.IsRolledBack {
		dAtA[i] = 0x20
		i++
		if m.IsRolledBack {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Event) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RegionId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionId))
	}
	if m.Index != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Index))
	}
	if m.Event != nil {
		nn7, err := m.Event.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn7
	}
	if m.RequestId != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RequestId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Event_Entries_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Entries != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Entries.Size()))
		n8, err := m.Entries.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}
func (m *Event_Admin_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Admin != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Admin.Size()))
		n9, err := m.Admin.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	return i, nil
}
func (m *Event_Error) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Error != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Error.Size()))
		n10, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}
func (m *Event_ResolvedTs) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x30
	i++
	i = encodeVarintCdcpb(dAtA, i, uint64(m.ResolvedTs))
	return i, nil
}
func (m *Event_LongTxn_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.LongTxn != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.LongTxn.Size()))
		n11, err := m.LongTxn.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *Event_Row) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Event_Row) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StartTs != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.StartTs))
	}
	if m.CommitTs != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.CommitTs))
	}
	if m.Type != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Type))
	}
	if m.OpType != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.OpType))
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Value) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	if len(m.OldValue) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.OldValue)))
		i += copy(dAtA[i:], m.OldValue)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Event_Entries) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, msg := range m.Entries {
			dAtA[i] = 0xa
			i++
			i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Event_Admin) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.AdminRequest != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.AdminRequest.Size()))
		n12, err := m.AdminRequest.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.AdminResponse != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.AdminResponse.Size()))
		n13, err := m.AdminResponse.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Event_LongTxn) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TxnInfo) > 0 {
		for _, msg := range m.TxnInfo {
			dAtA[i] = 0xa
			i++
			i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ChangeDataEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Events) > 0 {
		for _, msg := range m.Events {
			dAtA[i] = 0xa
			i++
			i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.ResolvedTs != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.ResolvedTs.Size()))
		n14, err := m.ResolvedTs.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ResolvedTs) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Regions) > 0 {
		dAtA16 := make([]byte, len(m.Regions)*10)
		var j15 int
		for _, num := range m.Regions {
			for num >= 1<<7 {
				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j15++
			}
			dAtA16[j15] = uint8(num)
			j15++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(j15))
		i += copy(dAtA[i:], dAtA16[:j15])
	}
	if m.Ts != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Ts))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ChangeDataRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Header.Size()))
		n17, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if m.RegionId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionId))
	}
	if m.RegionEpoch != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RegionEpoch.Size()))
		n18, err := m.RegionEpoch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.CheckpointTs != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.CheckpointTs))
	}
	if len(m.StartKey) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.StartKey)))
		i += copy(dAtA[i:], m.StartKey)
	}
	if len(m.EndKey) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(len(m.EndKey)))
		i += copy(dAtA[i:], m.EndKey)
	}
	if m.RequestId != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.RequestId))
	}
	if m.ExtraOp != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.ExtraOp))
	}
	if m.Request != nil {
		nn19, err := m.Request.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn19
	}
	if m.KvApi != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.KvApi))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ChangeDataRequest_Register_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Register != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.Register.Size()))
		n20, err := m.Register.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	return i, nil
}
func (m *ChangeDataRequest_NotifyTxnStatus_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.NotifyTxnStatus != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintCdcpb(dAtA, i, uint64(m.NotifyTxnStatus.Size()))
		n21, err := m.NotifyTxnStatus.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	return i, nil
}
func (m *ChangeDataRequest_Register) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChangeDataRequest_Register) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ChangeDataRequest_NotifyTxnStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TxnStatus) > 0 {
		for _, msg := range m.TxnStatus {
			dAtA[i] = 0xa
			i++
			i = encodeVarintCdcpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintCdcpb(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Header) Size() (n int) {
	var l int
	_ = l
	if m.ClusterId != 0 {
		n += 1 + sovCdcpb(uint64(m.ClusterId))
	}
	l = len(m.TicdcVersion)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *ClusterIDMismatch) Size() (n int) {
	var l int
	_ = l
	if m.Current != 0 {
		n += 1 + sovCdcpb(uint64(m.Current))
	}
	if m.Request != 0 {
		n += 1 + sovCdcpb(uint64(m.Request))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Error) Size() (n int) {
	var l int
	_ = l
	if m.NotLeader != nil {
		l = m.NotLeader.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.RegionNotFound != nil {
		l = m.RegionNotFound.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.EpochNotMatch != nil {
		l = m.EpochNotMatch.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.DuplicateRequest != nil {
		l = m.DuplicateRequest.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.Compatibility != nil {
		l = m.Compatibility.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.ClusterIdMismatch != nil {
		l = m.ClusterIdMismatch.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnInfo) Size() (n int) {
	var l int
	_ = l
	if m.StartTs != 0 {
		n += 1 + sovCdcpb(uint64(m.StartTs))
	}
	l = len(m.Primary)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxnStatus) Size() (n int) {
	var l int
	_ = l
	if m.StartTs != 0 {
		n += 1 + sovCdcpb(uint64(m.StartTs))
	}
	if m.MinCommitTs != 0 {
		n += 1 + sovCdcpb(uint64(m.MinCommitTs))
	}
	if m.CommitTs != 0 {
		n += 1 + sovCdcpb(uint64(m.CommitTs))
	}
	if m.IsRolledBack {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Event) Size() (n int) {
	var l int
	_ = l
	if m.RegionId != 0 {
		n += 1 + sovCdcpb(uint64(m.RegionId))
	}
	if m.Index != 0 {
		n += 1 + sovCdcpb(uint64(m.Index))
	}
	if m.Event != nil {
		n += m.Event.Size()
	}
	if m.RequestId != 0 {
		n += 1 + sovCdcpb(uint64(m.RequestId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Event_Entries_) Size() (n int) {
	var l int
	_ = l
	if m.Entries != nil {
		l = m.Entries.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	return n
}
func (m *Event_Admin_) Size() (n int) {
	var l int
	_ = l
	if m.Admin != nil {
		l = m.Admin.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	return n
}
func (m *Event_Error) Size() (n int) {
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	return n
}
func (m *Event_ResolvedTs) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovCdcpb(uint64(m.ResolvedTs))
	return n
}
func (m *Event_LongTxn_) Size() (n int) {
	var l int
	_ = l
	if m.LongTxn != nil {
		l = m.LongTxn.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	return n
}
func (m *Event_Row) Size() (n int) {
	var l int
	_ = l
	if m.StartTs != 0 {
		n += 1 + sovCdcpb(uint64(m.StartTs))
	}
	if m.CommitTs != 0 {
		n += 1 + sovCdcpb(uint64(m.CommitTs))
	}
	if m.Type != 0 {
		n += 1 + sovCdcpb(uint64(m.Type))
	}
	if m.OpType != 0 {
		n += 1 + sovCdcpb(uint64(m.OpType))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	l = len(m.OldValue)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Event_Admin) Size() (n int) {
	var l int
	_ = l
	if m.AdminRequest != nil {
		l = m.AdminRequest.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.AdminResponse != nil {
		l = m.AdminResponse.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

func (m *ChangeDataRequest) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.RegionId != 0 {
		n += 1 + sovCdcpb(uint64(m.RegionId))
	}
	if m.RegionEpoch != nil {
		l = m.RegionEpoch.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.CheckpointTs != 0 {
		n += 1 + sovCdcpb(uint64(m.CheckpointTs))
	}
	l = len(m.StartKey)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	l = len(m.EndKey)
	if l > 0 {
		n += 1 + l + sovCdcpb(uint64(l))
	}
	if m.RequestId != 0 {
		n += 1 + sovCdcpb(uint64(m.RequestId))
	}
	if m.ExtraOp != 0 {
		n += 1 + sovCdcpb(uint64(m.ExtraOp))
	}
	if m.Request != nil {
		n += m.Request.Size()
	}
	if m.KvApi != 0 {
		n += 1 + sovCdcpb(uint64(m.KvApi))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChangeDataRequest_Register_) Size() (n int) {
	var l int
	_ = l
	if m.Register != nil {
		l = m.Register.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	return n
}
func (m *ChangeDataRequest_NotifyTxnStatus_) Size() (n int) {
	var l int
	_ = l
	if m.NotifyTxnStatus != nil {
		l = m.NotifyTxnStatus.Size()
		n += 1 + l + sovCdcpb(uint64(l))
	}
	return n
}
func (m *ChangeDataRequest_Register) Size() (n int) {
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovCdcpb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozCdcpb(x uint64) (n int) {
	return sovCdcpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Header) 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 ErrIntOverflowCdcpb
			}
			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: Header: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			m.ClusterId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClusterId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TicdcVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				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 ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TicdcVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *DuplicateRequest) 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 ErrIntOverflowCdcpb
			}
			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: DuplicateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DuplicateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Compatibility) 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 ErrIntOverflowCdcpb
			}
			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: Compatibility: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Compatibility: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				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 ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequiredVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *ClusterIDMismatch) 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 ErrIntOverflowCdcpb
			}
			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: ClusterIDMismatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterIDMismatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType)
			}
			m.Current = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Current |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			m.Request = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Request |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Error) 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 ErrIntOverflowCdcpb
			}
			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: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotLeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NotLeader == nil {
				m.NotLeader = &errorpb.NotLeader{}
			}
			if err := m.NotLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionNotFound", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RegionNotFound == nil {
				m.RegionNotFound = &errorpb.RegionNotFound{}
			}
			if err := m.RegionNotFound.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochNotMatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EpochNotMatch == nil {
				m.EpochNotMatch = &errorpb.EpochNotMatch{}
			}
			if err := m.EpochNotMatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DuplicateRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DuplicateRequest == nil {
				m.DuplicateRequest = &DuplicateRequest{}
			}
			if err := m.DuplicateRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Compatibility", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Compatibility == nil {
				m.Compatibility = &Compatibility{}
			}
			if err := m.Compatibility.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdMismatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClusterIdMismatch == nil {
				m.ClusterIdMismatch = &ClusterIDMismatch{}
			}
			if err := m.ClusterIdMismatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *TxnInfo) 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 ErrIntOverflowCdcpb
			}
			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: TxnInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
			}
			m.StartTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Primary", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Primary = append(m.Primary[:0], dAtA[iNdEx:postIndex]...)
			if m.Primary == nil {
				m.Primary = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *TxnStatus) 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 ErrIntOverflowCdcpb
			}
			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: TxnStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxnStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
			}
			m.StartTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinCommitTs", wireType)
			}
			m.MinCommitTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinCommitTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType)
			}
			m.CommitTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsRolledBack", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsRolledBack = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Event) 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 ErrIntOverflowCdcpb
			}
			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: Event: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Event_Entries{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_Entries_{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Event_Admin{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_Admin_{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_Error{v}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Event = &Event_ResolvedTs{v}
		case 7:
			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 ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LongTxn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Event_LongTxn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_LongTxn_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Event_Row) 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 ErrIntOverflowCdcpb
			}
			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: Row: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType)
			}
			m.StartTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitTs", wireType)
			}
			m.CommitTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (Event_LogType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpType", wireType)
			}
			m.OpType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OpType |= (Event_Row_OpType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + byteLen
			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 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldValue", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OldValue = append(m.OldValue[:0], dAtA[iNdEx:postIndex]...)
			if m.OldValue == nil {
				m.OldValue = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Event_Entries) 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 ErrIntOverflowCdcpb
			}
			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: Entries: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Entries: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &Event_Row{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Event_Admin) 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 ErrIntOverflowCdcpb
			}
			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: Admin: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Admin: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AdminRequest == nil {
				m.AdminRequest = &raft_cmdpb.AdminRequest{}
			}
			if err := m.AdminRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AdminResponse == nil {
				m.AdminResponse = &raft_cmdpb.AdminResponse{}
			}
			if err := m.AdminResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *Event_LongTxn) 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 ErrIntOverflowCdcpb
			}
			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: LongTxn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LongTxn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnInfo = append(m.TxnInfo, &TxnInfo{})
			if err := m.TxnInfo[len(m.TxnInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *ChangeDataEvent) 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 ErrIntOverflowCdcpb
			}
			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: ChangeDataEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangeDataEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &Event{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResolvedTs == nil {
				m.ResolvedTs = &ResolvedTs{}
			}
			if err := m.ResolvedTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *ResolvedTs) 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 ErrIntOverflowCdcpb
			}
			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: ResolvedTs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResolvedTs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCdcpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Regions = append(m.Regions, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowCdcpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthCdcpb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowCdcpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Regions = append(m.Regions, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType)
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType)
			}
			m.Ts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ts |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *ChangeDataRequest) 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 ErrIntOverflowCdcpb
			}
			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: ChangeDataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangeDataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &Header{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RegionEpoch == nil {
				m.RegionEpoch = &metapb.RegionEpoch{}
			}
			if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckpointTs", wireType)
			}
			m.CheckpointTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckpointTs |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...)
			if m.StartKey == nil {
				m.StartKey = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EndKey == nil {
				m.EndKey = []byte{}
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraOp", wireType)
			}
			m.ExtraOp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExtraOp |= (kvrpcpb.ExtraOp(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Register", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeDataRequest_Register{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ChangeDataRequest_Register_{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotifyTxnStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ChangeDataRequest_NotifyTxnStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &ChangeDataRequest_NotifyTxnStatus_{v}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KvApi", wireType)
			}
			m.KvApi = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KvApi |= (ChangeDataRequest_KvAPI(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *ChangeDataRequest_Register) 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 ErrIntOverflowCdcpb
			}
			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: Register: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Register: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 *ChangeDataRequest_NotifyTxnStatus) 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 ErrIntOverflowCdcpb
			}
			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: NotifyTxnStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NotifyTxnStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCdcpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnStatus = append(m.TxnStatus, &TxnStatus{})
			if err := m.TxnStatus[len(m.TxnStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCdcpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCdcpb
			}
			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 skipCdcpb(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCdcpb
			}
			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, ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCdcpb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthCdcpb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowCdcpb
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipCdcpb(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthCdcpb = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCdcpb   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("cdcpb.proto", fileDescriptor_cdcpb_1c68e3d6625138c3) }

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