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

package pb

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"

	proto "github.com/gogo/protobuf/proto"
	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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type TaskOp int32

const (
	TaskOp_InvalidOp  TaskOp = 0
	TaskOp_Stop       TaskOp = 1
	TaskOp_Pause      TaskOp = 2
	TaskOp_Resume     TaskOp = 3
	TaskOp_Start      TaskOp = 4
	TaskOp_Update     TaskOp = 5
	TaskOp_AutoResume TaskOp = 6
)

var TaskOp_name = map[int32]string{
	0: "InvalidOp",
	1: "Stop",
	2: "Pause",
	3: "Resume",
	4: "Start",
	5: "Update",
	6: "AutoResume",
}

var TaskOp_value = map[string]int32{
	"InvalidOp":  0,
	"Stop":       1,
	"Pause":      2,
	"Resume":     3,
	"Start":      4,
	"Update":     5,
	"AutoResume": 6,
}

func (x TaskOp) String() string {
	return proto.EnumName(TaskOp_name, int32(x))
}

func (TaskOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{0}
}

type SQLOp int32

const (
	SQLOp_SKIP    SQLOp = 0
	SQLOp_REPLACE SQLOp = 1
	SQLOp_INJECT  SQLOp = 2
)

var SQLOp_name = map[int32]string{
	0: "SKIP",
	1: "REPLACE",
	2: "INJECT",
}

var SQLOp_value = map[string]int32{
	"SKIP":    0,
	"REPLACE": 1,
	"INJECT":  2,
}

func (x SQLOp) String() string {
	return proto.EnumName(SQLOp_name, int32(x))
}

func (SQLOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{1}
}

// Stage represents current stage for a (sub) task
// a (sub) task should be always in one stage of the following stages
// (sub) task can transfer from on stage to some special other stages
// New: initial stage when a sub task is created
//      can not transfered from other stages
//      transfer to Running when initialize with no error
// Running: indicates the sub task is processing
//          transfered from New when created successfully
//          transfered from Paused when resuming is requested
//          transfer to Paused when error occured or requested from external
//          transfer to Stopped when requested from external
//          transfer to Finished when sub task processing completed (no Syncer used)
// Paused: indicates the processing is paused, and can be resume from external request
//         transfered from Running when error occured or requested from external
//         transfer to Running when resuming is requested from external
//         transfer to Stopped when requested from external
// Stopped: indicates the processing is stopped, and can not be resume (or re-run) again
//          transfered from Running / Paused when requested from external
//          can not transfer to any stages
// Finished: indicates the processing is finished, and no need to re-run
//           transfered from Running when processing completed
//           should not transfer to any stages
type Stage int32

const (
	Stage_InvalidStage Stage = 0
	Stage_New          Stage = 1
	Stage_Running      Stage = 2
	Stage_Paused       Stage = 3
	Stage_Stopped      Stage = 4
	Stage_Finished     Stage = 5
)

var Stage_name = map[int32]string{
	0: "InvalidStage",
	1: "New",
	2: "Running",
	3: "Paused",
	4: "Stopped",
	5: "Finished",
}

var Stage_value = map[string]int32{
	"InvalidStage": 0,
	"New":          1,
	"Running":      2,
	"Paused":       3,
	"Stopped":      4,
	"Finished":     5,
}

func (x Stage) String() string {
	return proto.EnumName(Stage_name, int32(x))
}

func (Stage) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{2}
}

// UnitType represents the dm unit's type
type UnitType int32

const (
	UnitType_InvalidUnit UnitType = 0
	UnitType_Check       UnitType = 1
	UnitType_Dump        UnitType = 2
	UnitType_Load        UnitType = 3
	UnitType_Sync        UnitType = 4
	UnitType_Relay       UnitType = 100
)

var UnitType_name = map[int32]string{
	0:   "InvalidUnit",
	1:   "Check",
	2:   "Dump",
	3:   "Load",
	4:   "Sync",
	100: "Relay",
}

var UnitType_value = map[string]int32{
	"InvalidUnit": 0,
	"Check":       1,
	"Dump":        2,
	"Load":        3,
	"Sync":        4,
	"Relay":       100,
}

func (x UnitType) String() string {
	return proto.EnumName(UnitType_name, int32(x))
}

func (UnitType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{3}
}

// ErrorType represents type of error produced by a dm unit
// NOTE: add new if needed
type ErrorType int32

const (
	ErrorType_UnknownError ErrorType = 0
	ErrorType_ExecSQL      ErrorType = 1
	ErrorType_CheckFailed  ErrorType = 2
)

var ErrorType_name = map[int32]string{
	0: "UnknownError",
	1: "ExecSQL",
	2: "CheckFailed",
}

var ErrorType_value = map[string]int32{
	"UnknownError": 0,
	"ExecSQL":      1,
	"CheckFailed":  2,
}

func (x ErrorType) String() string {
	return proto.EnumName(ErrorType_name, int32(x))
}

func (ErrorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{4}
}

// RelayOp differs from TaskOp
type RelayOp int32

const (
	RelayOp_InvalidRelayOp RelayOp = 0
	RelayOp_StopRelay      RelayOp = 1
	RelayOp_PauseRelay     RelayOp = 2
	RelayOp_ResumeRelay    RelayOp = 3
)

var RelayOp_name = map[int32]string{
	0: "InvalidRelayOp",
	1: "StopRelay",
	2: "PauseRelay",
	3: "ResumeRelay",
}

var RelayOp_value = map[string]int32{
	"InvalidRelayOp": 0,
	"StopRelay":      1,
	"PauseRelay":     2,
	"ResumeRelay":    3,
}

func (x RelayOp) String() string {
	return proto.EnumName(RelayOp_name, int32(x))
}

func (RelayOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{5}
}

type StartSubTaskRequest struct {
	Task string `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
}

func (m *StartSubTaskRequest) Reset()         { *m = StartSubTaskRequest{} }
func (m *StartSubTaskRequest) String() string { return proto.CompactTextString(m) }
func (*StartSubTaskRequest) ProtoMessage()    {}
func (*StartSubTaskRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{0}
}
func (m *StartSubTaskRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StartSubTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StartSubTaskRequest.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 (m *StartSubTaskRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartSubTaskRequest.Merge(m, src)
}
func (m *StartSubTaskRequest) XXX_Size() int {
	return m.Size()
}
func (m *StartSubTaskRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StartSubTaskRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StartSubTaskRequest proto.InternalMessageInfo

func (m *StartSubTaskRequest) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

type UpdateRelayRequest struct {
	Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
}

func (m *UpdateRelayRequest) Reset()         { *m = UpdateRelayRequest{} }
func (m *UpdateRelayRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateRelayRequest) ProtoMessage()    {}
func (*UpdateRelayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{1}
}
func (m *UpdateRelayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateRelayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateRelayRequest.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 (m *UpdateRelayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateRelayRequest.Merge(m, src)
}
func (m *UpdateRelayRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateRelayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateRelayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateRelayRequest proto.InternalMessageInfo

func (m *UpdateRelayRequest) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type MigrateRelayRequest struct {
	BinlogName string `protobuf:"bytes,1,opt,name=BinlogName,proto3" json:"BinlogName,omitempty"`
	BinlogPos  uint32 `protobuf:"varint,2,opt,name=BinlogPos,proto3" json:"BinlogPos,omitempty"`
}

func (m *MigrateRelayRequest) Reset()         { *m = MigrateRelayRequest{} }
func (m *MigrateRelayRequest) String() string { return proto.CompactTextString(m) }
func (*MigrateRelayRequest) ProtoMessage()    {}
func (*MigrateRelayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{2}
}
func (m *MigrateRelayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MigrateRelayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MigrateRelayRequest.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 (m *MigrateRelayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MigrateRelayRequest.Merge(m, src)
}
func (m *MigrateRelayRequest) XXX_Size() int {
	return m.Size()
}
func (m *MigrateRelayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MigrateRelayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MigrateRelayRequest proto.InternalMessageInfo

func (m *MigrateRelayRequest) GetBinlogName() string {
	if m != nil {
		return m.BinlogName
	}
	return ""
}

func (m *MigrateRelayRequest) GetBinlogPos() uint32 {
	if m != nil {
		return m.BinlogPos
	}
	return 0
}

type OperateSubTaskRequest struct {
	Op   TaskOp `protobuf:"varint,1,opt,name=op,proto3,enum=pb.TaskOp" json:"op,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *OperateSubTaskRequest) Reset()         { *m = OperateSubTaskRequest{} }
func (m *OperateSubTaskRequest) String() string { return proto.CompactTextString(m) }
func (*OperateSubTaskRequest) ProtoMessage()    {}
func (*OperateSubTaskRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{3}
}
func (m *OperateSubTaskRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OperateSubTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OperateSubTaskRequest.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 (m *OperateSubTaskRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OperateSubTaskRequest.Merge(m, src)
}
func (m *OperateSubTaskRequest) XXX_Size() int {
	return m.Size()
}
func (m *OperateSubTaskRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_OperateSubTaskRequest.DiscardUnknown(m)
}

var xxx_messageInfo_OperateSubTaskRequest proto.InternalMessageInfo

func (m *OperateSubTaskRequest) GetOp() TaskOp {
	if m != nil {
		return m.Op
	}
	return TaskOp_InvalidOp
}

func (m *OperateSubTaskRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type OperateSubTaskResponse struct {
	Meta  *CommonWorkerResponse `protobuf:"bytes,1,opt,name=meta,proto3" json:"meta,omitempty"`
	Op    TaskOp                `protobuf:"varint,2,opt,name=op,proto3,enum=pb.TaskOp" json:"op,omitempty"`
	LogID int64                 `protobuf:"varint,3,opt,name=logID,proto3" json:"logID,omitempty"`
}

func (m *OperateSubTaskResponse) Reset()         { *m = OperateSubTaskResponse{} }
func (m *OperateSubTaskResponse) String() string { return proto.CompactTextString(m) }
func (*OperateSubTaskResponse) ProtoMessage()    {}
func (*OperateSubTaskResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{4}
}
func (m *OperateSubTaskResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OperateSubTaskResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OperateSubTaskResponse.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 (m *OperateSubTaskResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OperateSubTaskResponse.Merge(m, src)
}
func (m *OperateSubTaskResponse) XXX_Size() int {
	return m.Size()
}
func (m *OperateSubTaskResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_OperateSubTaskResponse.DiscardUnknown(m)
}

var xxx_messageInfo_OperateSubTaskResponse proto.InternalMessageInfo

func (m *OperateSubTaskResponse) GetMeta() *CommonWorkerResponse {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *OperateSubTaskResponse) GetOp() TaskOp {
	if m != nil {
		return m.Op
	}
	return TaskOp_InvalidOp
}

func (m *OperateSubTaskResponse) GetLogID() int64 {
	if m != nil {
		return m.LogID
	}
	return 0
}

type QueryTaskOperationRequest struct {
	Name  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	LogID int64  `protobuf:"varint,2,opt,name=logID,proto3" json:"logID,omitempty"`
}

func (m *QueryTaskOperationRequest) Reset()         { *m = QueryTaskOperationRequest{} }
func (m *QueryTaskOperationRequest) String() string { return proto.CompactTextString(m) }
func (*QueryTaskOperationRequest) ProtoMessage()    {}
func (*QueryTaskOperationRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{5}
}
func (m *QueryTaskOperationRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryTaskOperationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryTaskOperationRequest.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 (m *QueryTaskOperationRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTaskOperationRequest.Merge(m, src)
}
func (m *QueryTaskOperationRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryTaskOperationRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTaskOperationRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTaskOperationRequest proto.InternalMessageInfo

func (m *QueryTaskOperationRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *QueryTaskOperationRequest) GetLogID() int64 {
	if m != nil {
		return m.LogID
	}
	return 0
}

type QueryTaskOperationResponse struct {
	Meta *CommonWorkerResponse `protobuf:"bytes,1,opt,name=meta,proto3" json:"meta,omitempty"`
	Log  *TaskLog              `protobuf:"bytes,2,opt,name=log,proto3" json:"log,omitempty"`
}

func (m *QueryTaskOperationResponse) Reset()         { *m = QueryTaskOperationResponse{} }
func (m *QueryTaskOperationResponse) String() string { return proto.CompactTextString(m) }
func (*QueryTaskOperationResponse) ProtoMessage()    {}
func (*QueryTaskOperationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{6}
}
func (m *QueryTaskOperationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryTaskOperationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryTaskOperationResponse.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 (m *QueryTaskOperationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTaskOperationResponse.Merge(m, src)
}
func (m *QueryTaskOperationResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryTaskOperationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTaskOperationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTaskOperationResponse proto.InternalMessageInfo

func (m *QueryTaskOperationResponse) GetMeta() *CommonWorkerResponse {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *QueryTaskOperationResponse) GetLog() *TaskLog {
	if m != nil {
		return m.Log
	}
	return nil
}

type UpdateSubTaskRequest struct {
	Task string `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
}

func (m *UpdateSubTaskRequest) Reset()         { *m = UpdateSubTaskRequest{} }
func (m *UpdateSubTaskRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateSubTaskRequest) ProtoMessage()    {}
func (*UpdateSubTaskRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{7}
}
func (m *UpdateSubTaskRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UpdateSubTaskRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UpdateSubTaskRequest.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 (m *UpdateSubTaskRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateSubTaskRequest.Merge(m, src)
}
func (m *UpdateSubTaskRequest) XXX_Size() int {
	return m.Size()
}
func (m *UpdateSubTaskRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateSubTaskRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateSubTaskRequest proto.InternalMessageInfo

func (m *UpdateSubTaskRequest) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

type QueryStatusRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *QueryStatusRequest) Reset()         { *m = QueryStatusRequest{} }
func (m *QueryStatusRequest) String() string { return proto.CompactTextString(m) }
func (*QueryStatusRequest) ProtoMessage()    {}
func (*QueryStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{8}
}
func (m *QueryStatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryStatusRequest.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 (m *QueryStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryStatusRequest.Merge(m, src)
}
func (m *QueryStatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryStatusRequest proto.InternalMessageInfo

func (m *QueryStatusRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type QueryErrorRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *QueryErrorRequest) Reset()         { *m = QueryErrorRequest{} }
func (m *QueryErrorRequest) String() string { return proto.CompactTextString(m) }
func (*QueryErrorRequest) ProtoMessage()    {}
func (*QueryErrorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{9}
}
func (m *QueryErrorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryErrorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryErrorRequest.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 (m *QueryErrorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryErrorRequest.Merge(m, src)
}
func (m *QueryErrorRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryErrorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryErrorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryErrorRequest proto.InternalMessageInfo

func (m *QueryErrorRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// NOTE: we can extract some common(optional) arguments from `args`, like `meta`
type HandleSubTaskSQLsRequest struct {
	Name       string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Op         SQLOp    `protobuf:"varint,2,opt,name=op,proto3,enum=pb.SQLOp" json:"op,omitempty"`
	Args       []string `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	BinlogPos  string   `protobuf:"bytes,4,opt,name=binlogPos,proto3" json:"binlogPos,omitempty"`
	SqlPattern string   `protobuf:"bytes,5,opt,name=sqlPattern,proto3" json:"sqlPattern,omitempty"`
}

func (m *HandleSubTaskSQLsRequest) Reset()         { *m = HandleSubTaskSQLsRequest{} }
func (m *HandleSubTaskSQLsRequest) String() string { return proto.CompactTextString(m) }
func (*HandleSubTaskSQLsRequest) ProtoMessage()    {}
func (*HandleSubTaskSQLsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{10}
}
func (m *HandleSubTaskSQLsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HandleSubTaskSQLsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HandleSubTaskSQLsRequest.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 (m *HandleSubTaskSQLsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HandleSubTaskSQLsRequest.Merge(m, src)
}
func (m *HandleSubTaskSQLsRequest) XXX_Size() int {
	return m.Size()
}
func (m *HandleSubTaskSQLsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HandleSubTaskSQLsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_HandleSubTaskSQLsRequest proto.InternalMessageInfo

func (m *HandleSubTaskSQLsRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *HandleSubTaskSQLsRequest) GetOp() SQLOp {
	if m != nil {
		return m.Op
	}
	return SQLOp_SKIP
}

func (m *HandleSubTaskSQLsRequest) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *HandleSubTaskSQLsRequest) GetBinlogPos() string {
	if m != nil {
		return m.BinlogPos
	}
	return ""
}

func (m *HandleSubTaskSQLsRequest) GetSqlPattern() string {
	if m != nil {
		return m.SqlPattern
	}
	return ""
}

type CommonWorkerResponse struct {
	Result bool   `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
	Worker string `protobuf:"bytes,2,opt,name=worker,proto3" json:"worker,omitempty"`
	Msg    string `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *CommonWorkerResponse) Reset()         { *m = CommonWorkerResponse{} }
func (m *CommonWorkerResponse) String() string { return proto.CompactTextString(m) }
func (*CommonWorkerResponse) ProtoMessage()    {}
func (*CommonWorkerResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{11}
}
func (m *CommonWorkerResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommonWorkerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommonWorkerResponse.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 (m *CommonWorkerResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommonWorkerResponse.Merge(m, src)
}
func (m *CommonWorkerResponse) XXX_Size() int {
	return m.Size()
}
func (m *CommonWorkerResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CommonWorkerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CommonWorkerResponse proto.InternalMessageInfo

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

func (m *CommonWorkerResponse) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

func (m *CommonWorkerResponse) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// QueryStatusResponse represents status response for query on a dm-worker
// status: dm-worker's current sub tasks' status
type QueryStatusResponse struct {
	Result        bool             `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
	Worker        string           `protobuf:"bytes,2,opt,name=worker,proto3" json:"worker,omitempty"`
	Msg           string           `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	SubTaskStatus []*SubTaskStatus `protobuf:"bytes,4,rep,name=subTaskStatus,proto3" json:"subTaskStatus,omitempty"`
	RelayStatus   *RelayStatus     `protobuf:"bytes,5,opt,name=relayStatus,proto3" json:"relayStatus,omitempty"`
	SourceID      string           `protobuf:"bytes,6,opt,name=sourceID,proto3" json:"sourceID,omitempty"`
}

func (m *QueryStatusResponse) Reset()         { *m = QueryStatusResponse{} }
func (m *QueryStatusResponse) String() string { return proto.CompactTextString(m) }
func (*QueryStatusResponse) ProtoMessage()    {}
func (*QueryStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{12}
}
func (m *QueryStatusResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryStatusResponse.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 (m *QueryStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryStatusResponse.Merge(m, src)
}
func (m *QueryStatusResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryStatusResponse proto.InternalMessageInfo

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

func (m *QueryStatusResponse) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

func (m *QueryStatusResponse) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *QueryStatusResponse) GetSubTaskStatus() []*SubTaskStatus {
	if m != nil {
		return m.SubTaskStatus
	}
	return nil
}

func (m *QueryStatusResponse) GetRelayStatus() *RelayStatus {
	if m != nil {
		return m.RelayStatus
	}
	return nil
}

func (m *QueryStatusResponse) GetSourceID() string {
	if m != nil {
		return m.SourceID
	}
	return ""
}

// QueryErrorResponse represents response for query on a dm-worker
type QueryErrorResponse struct {
	Result       bool            `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
	Worker       string          `protobuf:"bytes,2,opt,name=worker,proto3" json:"worker,omitempty"`
	Msg          string          `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	SubTaskError []*SubTaskError `protobuf:"bytes,4,rep,name=subTaskError,proto3" json:"subTaskError,omitempty"`
	RelayError   *RelayError     `protobuf:"bytes,5,opt,name=RelayError,proto3" json:"RelayError,omitempty"`
}

func (m *QueryErrorResponse) Reset()         { *m = QueryErrorResponse{} }
func (m *QueryErrorResponse) String() string { return proto.CompactTextString(m) }
func (*QueryErrorResponse) ProtoMessage()    {}
func (*QueryErrorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{13}
}
func (m *QueryErrorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryErrorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryErrorResponse.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 (m *QueryErrorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryErrorResponse.Merge(m, src)
}
func (m *QueryErrorResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryErrorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryErrorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryErrorResponse proto.InternalMessageInfo

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

func (m *QueryErrorResponse) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

func (m *QueryErrorResponse) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *QueryErrorResponse) GetSubTaskError() []*SubTaskError {
	if m != nil {
		return m.SubTaskError
	}
	return nil
}

func (m *QueryErrorResponse) GetRelayError() *RelayError {
	if m != nil {
		return m.RelayError
	}
	return nil
}

// CheckStatus represents status for check unit
// adds fields later
type CheckStatus struct {
	Passed     bool   `protobuf:"varint,1,opt,name=passed,proto3" json:"passed,omitempty"`
	Total      int32  `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
	Successful int32  `protobuf:"varint,3,opt,name=successful,proto3" json:"successful,omitempty"`
	Failed     int32  `protobuf:"varint,4,opt,name=failed,proto3" json:"failed,omitempty"`
	Warning    int32  `protobuf:"varint,5,opt,name=warning,proto3" json:"warning,omitempty"`
	Detail     []byte `protobuf:"bytes,6,opt,name=detail,proto3" json:"detail,omitempty"`
}

func (m *CheckStatus) Reset()         { *m = CheckStatus{} }
func (m *CheckStatus) String() string { return proto.CompactTextString(m) }
func (*CheckStatus) ProtoMessage()    {}
func (*CheckStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{14}
}
func (m *CheckStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CheckStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CheckStatus.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 (m *CheckStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckStatus.Merge(m, src)
}
func (m *CheckStatus) XXX_Size() int {
	return m.Size()
}
func (m *CheckStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckStatus.DiscardUnknown(m)
}

var xxx_messageInfo_CheckStatus proto.InternalMessageInfo

func (m *CheckStatus) GetPassed() bool {
	if m != nil {
		return m.Passed
	}
	return false
}

func (m *CheckStatus) GetTotal() int32 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *CheckStatus) GetSuccessful() int32 {
	if m != nil {
		return m.Successful
	}
	return 0
}

func (m *CheckStatus) GetFailed() int32 {
	if m != nil {
		return m.Failed
	}
	return 0
}

func (m *CheckStatus) GetWarning() int32 {
	if m != nil {
		return m.Warning
	}
	return 0
}

func (m *CheckStatus) GetDetail() []byte {
	if m != nil {
		return m.Detail
	}
	return nil
}

// DumpStatus represents status for dump unit
// add fields later
type DumpStatus struct {
}

func (m *DumpStatus) Reset()         { *m = DumpStatus{} }
func (m *DumpStatus) String() string { return proto.CompactTextString(m) }
func (*DumpStatus) ProtoMessage()    {}
func (*DumpStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{15}
}
func (m *DumpStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DumpStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DumpStatus.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 (m *DumpStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DumpStatus.Merge(m, src)
}
func (m *DumpStatus) XXX_Size() int {
	return m.Size()
}
func (m *DumpStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_DumpStatus.DiscardUnknown(m)
}

var xxx_messageInfo_DumpStatus proto.InternalMessageInfo

// LoadStatus represents status for load unit
type LoadStatus struct {
	FinishedBytes int64  `protobuf:"varint,1,opt,name=finishedBytes,proto3" json:"finishedBytes,omitempty"`
	TotalBytes    int64  `protobuf:"varint,2,opt,name=totalBytes,proto3" json:"totalBytes,omitempty"`
	Progress      string `protobuf:"bytes,3,opt,name=progress,proto3" json:"progress,omitempty"`
	MetaBinlog    string `protobuf:"bytes,4,opt,name=metaBinlog,proto3" json:"metaBinlog,omitempty"`
}

func (m *LoadStatus) Reset()         { *m = LoadStatus{} }
func (m *LoadStatus) String() string { return proto.CompactTextString(m) }
func (*LoadStatus) ProtoMessage()    {}
func (*LoadStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{16}
}
func (m *LoadStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LoadStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LoadStatus.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 (m *LoadStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadStatus.Merge(m, src)
}
func (m *LoadStatus) XXX_Size() int {
	return m.Size()
}
func (m *LoadStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadStatus.DiscardUnknown(m)
}

var xxx_messageInfo_LoadStatus proto.InternalMessageInfo

func (m *LoadStatus) GetFinishedBytes() int64 {
	if m != nil {
		return m.FinishedBytes
	}
	return 0
}

func (m *LoadStatus) GetTotalBytes() int64 {
	if m != nil {
		return m.TotalBytes
	}
	return 0
}

func (m *LoadStatus) GetProgress() string {
	if m != nil {
		return m.Progress
	}
	return ""
}

func (m *LoadStatus) GetMetaBinlog() string {
	if m != nil {
		return m.MetaBinlog
	}
	return ""
}

// ShardingGroup represents a DDL sharding group, this is used by SyncStatus, and is differ from ShardingGroup in syncer pkg
// target: target table name
// DDL: in syncing DDL
// firstPos: first DDL binlog pos for this group
// synced: synced source tables
// unsynced: unsynced source tables
type ShardingGroup struct {
	Target   string   `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	DDLs     []string `protobuf:"bytes,2,rep,name=DDLs,proto3" json:"DDLs,omitempty"`
	FirstPos string   `protobuf:"bytes,3,opt,name=firstPos,proto3" json:"firstPos,omitempty"`
	Synced   []string `protobuf:"bytes,4,rep,name=synced,proto3" json:"synced,omitempty"`
	Unsynced []string `protobuf:"bytes,5,rep,name=unsynced,proto3" json:"unsynced,omitempty"`
}

func (m *ShardingGroup) Reset()         { *m = ShardingGroup{} }
func (m *ShardingGroup) String() string { return proto.CompactTextString(m) }
func (*ShardingGroup) ProtoMessage()    {}
func (*ShardingGroup) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{17}
}
func (m *ShardingGroup) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardingGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ShardingGroup.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 (m *ShardingGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardingGroup.Merge(m, src)
}
func (m *ShardingGroup) XXX_Size() int {
	return m.Size()
}
func (m *ShardingGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardingGroup.DiscardUnknown(m)
}

var xxx_messageInfo_ShardingGroup proto.InternalMessageInfo

func (m *ShardingGroup) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *ShardingGroup) GetDDLs() []string {
	if m != nil {
		return m.DDLs
	}
	return nil
}

func (m *ShardingGroup) GetFirstPos() string {
	if m != nil {
		return m.FirstPos
	}
	return ""
}

func (m *ShardingGroup) GetSynced() []string {
	if m != nil {
		return m.Synced
	}
	return nil
}

func (m *ShardingGroup) GetUnsynced() []string {
	if m != nil {
		return m.Unsynced
	}
	return nil
}

// SyncStatus represents status for sync unit
type SyncStatus struct {
	TotalEvents      int64            `protobuf:"varint,1,opt,name=totalEvents,proto3" json:"totalEvents,omitempty"`
	TotalTps         int64            `protobuf:"varint,2,opt,name=totalTps,proto3" json:"totalTps,omitempty"`
	RecentTps        int64            `protobuf:"varint,3,opt,name=recentTps,proto3" json:"recentTps,omitempty"`
	MasterBinlog     string           `protobuf:"bytes,4,opt,name=masterBinlog,proto3" json:"masterBinlog,omitempty"`
	MasterBinlogGtid string           `protobuf:"bytes,5,opt,name=masterBinlogGtid,proto3" json:"masterBinlogGtid,omitempty"`
	SyncerBinlog     string           `protobuf:"bytes,6,opt,name=syncerBinlog,proto3" json:"syncerBinlog,omitempty"`
	SyncerBinlogGtid string           `protobuf:"bytes,7,opt,name=syncerBinlogGtid,proto3" json:"syncerBinlogGtid,omitempty"`
	BlockingDDLs     []string         `protobuf:"bytes,8,rep,name=blockingDDLs,proto3" json:"blockingDDLs,omitempty"`
	UnresolvedGroups []*ShardingGroup `protobuf:"bytes,9,rep,name=unresolvedGroups,proto3" json:"unresolvedGroups,omitempty"`
	Synced           bool             `protobuf:"varint,10,opt,name=synced,proto3" json:"synced,omitempty"`
}

func (m *SyncStatus) Reset()         { *m = SyncStatus{} }
func (m *SyncStatus) String() string { return proto.CompactTextString(m) }
func (*SyncStatus) ProtoMessage()    {}
func (*SyncStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{18}
}
func (m *SyncStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SyncStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SyncStatus.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 (m *SyncStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncStatus.Merge(m, src)
}
func (m *SyncStatus) XXX_Size() int {
	return m.Size()
}
func (m *SyncStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncStatus.DiscardUnknown(m)
}

var xxx_messageInfo_SyncStatus proto.InternalMessageInfo

func (m *SyncStatus) GetTotalEvents() int64 {
	if m != nil {
		return m.TotalEvents
	}
	return 0
}

func (m *SyncStatus) GetTotalTps() int64 {
	if m != nil {
		return m.TotalTps
	}
	return 0
}

func (m *SyncStatus) GetRecentTps() int64 {
	if m != nil {
		return m.RecentTps
	}
	return 0
}

func (m *SyncStatus) GetMasterBinlog() string {
	if m != nil {
		return m.MasterBinlog
	}
	return ""
}

func (m *SyncStatus) GetMasterBinlogGtid() string {
	if m != nil {
		return m.MasterBinlogGtid
	}
	return ""
}

func (m *SyncStatus) GetSyncerBinlog() string {
	if m != nil {
		return m.SyncerBinlog
	}
	return ""
}

func (m *SyncStatus) GetSyncerBinlogGtid() string {
	if m != nil {
		return m.SyncerBinlogGtid
	}
	return ""
}

func (m *SyncStatus) GetBlockingDDLs() []string {
	if m != nil {
		return m.BlockingDDLs
	}
	return nil
}

func (m *SyncStatus) GetUnresolvedGroups() []*ShardingGroup {
	if m != nil {
		return m.UnresolvedGroups
	}
	return nil
}

func (m *SyncStatus) GetSynced() bool {
	if m != nil {
		return m.Synced
	}
	return false
}

// RelayStatus represents status for relay unit.
type RelayStatus struct {
	MasterBinlog       string         `protobuf:"bytes,1,opt,name=masterBinlog,proto3" json:"masterBinlog,omitempty"`
	MasterBinlogGtid   string         `protobuf:"bytes,2,opt,name=masterBinlogGtid,proto3" json:"masterBinlogGtid,omitempty"`
	RelaySubDir        string         `protobuf:"bytes,3,opt,name=relaySubDir,proto3" json:"relaySubDir,omitempty"`
	RelayBinlog        string         `protobuf:"bytes,4,opt,name=relayBinlog,proto3" json:"relayBinlog,omitempty"`
	RelayBinlogGtid    string         `protobuf:"bytes,5,opt,name=relayBinlogGtid,proto3" json:"relayBinlogGtid,omitempty"`
	RelayCatchUpMaster bool           `protobuf:"varint,6,opt,name=relayCatchUpMaster,proto3" json:"relayCatchUpMaster,omitempty"`
	Stage              Stage          `protobuf:"varint,7,opt,name=stage,proto3,enum=pb.Stage" json:"stage,omitempty"`
	Result             *ProcessResult `protobuf:"bytes,8,opt,name=result,proto3" json:"result,omitempty"`
}

func (m *RelayStatus) Reset()         { *m = RelayStatus{} }
func (m *RelayStatus) String() string { return proto.CompactTextString(m) }
func (*RelayStatus) ProtoMessage()    {}
func (*RelayStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{19}
}
func (m *RelayStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RelayStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RelayStatus.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 (m *RelayStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayStatus.Merge(m, src)
}
func (m *RelayStatus) XXX_Size() int {
	return m.Size()
}
func (m *RelayStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayStatus.DiscardUnknown(m)
}

var xxx_messageInfo_RelayStatus proto.InternalMessageInfo

func (m *RelayStatus) GetMasterBinlog() string {
	if m != nil {
		return m.MasterBinlog
	}
	return ""
}

func (m *RelayStatus) GetMasterBinlogGtid() string {
	if m != nil {
		return m.MasterBinlogGtid
	}
	return ""
}

func (m *RelayStatus) GetRelaySubDir() string {
	if m != nil {
		return m.RelaySubDir
	}
	return ""
}

func (m *RelayStatus) GetRelayBinlog() string {
	if m != nil {
		return m.RelayBinlog
	}
	return ""
}

func (m *RelayStatus) GetRelayBinlogGtid() string {
	if m != nil {
		return m.RelayBinlogGtid
	}
	return ""
}

func (m *RelayStatus) GetRelayCatchUpMaster() bool {
	if m != nil {
		return m.RelayCatchUpMaster
	}
	return false
}

func (m *RelayStatus) GetStage() Stage {
	if m != nil {
		return m.Stage
	}
	return Stage_InvalidStage
}

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

// SubTaskStatus represents status for a sub task
// name: sub task'name, when starting a sub task the name should be unique
// stage: sub task's current stage
// unit: sub task's current dm unit's UnitType
// result: current unit's process result, when the stage is Running, no result
// unresolvedDDLLockID: un-resolved sharding DDL lock ID (ref DDLLockInfo)
//                      if needed, we can put this to SyncStatus
// status: current unit's statistics
//         for Load, includes total bytes, progress, etc.
//         for Sync, includes TPS, binlog meta, etc.
type SubTaskStatus struct {
	Name                string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Stage               Stage          `protobuf:"varint,2,opt,name=stage,proto3,enum=pb.Stage" json:"stage,omitempty"`
	Unit                UnitType       `protobuf:"varint,3,opt,name=unit,proto3,enum=pb.UnitType" json:"unit,omitempty"`
	Result              *ProcessResult `protobuf:"bytes,4,opt,name=result,proto3" json:"result,omitempty"`
	UnresolvedDDLLockID string         `protobuf:"bytes,5,opt,name=unresolvedDDLLockID,proto3" json:"unresolvedDDLLockID,omitempty"`
	// Types that are valid to be assigned to Status:
	//	*SubTaskStatus_Msg
	//	*SubTaskStatus_Check
	//	*SubTaskStatus_Dump
	//	*SubTaskStatus_Load
	//	*SubTaskStatus_Sync
	Status isSubTaskStatus_Status `protobuf_oneof:"status"`
}

func (m *SubTaskStatus) Reset()         { *m = SubTaskStatus{} }
func (m *SubTaskStatus) String() string { return proto.CompactTextString(m) }
func (*SubTaskStatus) ProtoMessage()    {}
func (*SubTaskStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{20}
}
func (m *SubTaskStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubTaskStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubTaskStatus.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 (m *SubTaskStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubTaskStatus.Merge(m, src)
}
func (m *SubTaskStatus) XXX_Size() int {
	return m.Size()
}
func (m *SubTaskStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_SubTaskStatus.DiscardUnknown(m)
}

var xxx_messageInfo_SubTaskStatus proto.InternalMessageInfo

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

type SubTaskStatus_Msg struct {
	Msg string `protobuf:"bytes,6,opt,name=msg,proto3,oneof"`
}
type SubTaskStatus_Check struct {
	Check *CheckStatus `protobuf:"bytes,7,opt,name=check,proto3,oneof"`
}
type SubTaskStatus_Dump struct {
	Dump *DumpStatus `protobuf:"bytes,8,opt,name=dump,proto3,oneof"`
}
type SubTaskStatus_Load struct {
	Load *LoadStatus `protobuf:"bytes,9,opt,name=load,proto3,oneof"`
}
type SubTaskStatus_Sync struct {
	Sync *SyncStatus `protobuf:"bytes,10,opt,name=sync,proto3,oneof"`
}

func (*SubTaskStatus_Msg) isSubTaskStatus_Status()   {}
func (*SubTaskStatus_Check) isSubTaskStatus_Status() {}
func (*SubTaskStatus_Dump) isSubTaskStatus_Status()  {}
func (*SubTaskStatus_Load) isSubTaskStatus_Status()  {}
func (*SubTaskStatus_Sync) isSubTaskStatus_Status()  {}

func (m *SubTaskStatus) GetStatus() isSubTaskStatus_Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *SubTaskStatus) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SubTaskStatus) GetStage() Stage {
	if m != nil {
		return m.Stage
	}
	return Stage_InvalidStage
}

func (m *SubTaskStatus) GetUnit() UnitType {
	if m != nil {
		return m.Unit
	}
	return UnitType_InvalidUnit
}

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

func (m *SubTaskStatus) GetUnresolvedDDLLockID() string {
	if m != nil {
		return m.UnresolvedDDLLockID
	}
	return ""
}

func (m *SubTaskStatus) GetMsg() string {
	if x, ok := m.GetStatus().(*SubTaskStatus_Msg); ok {
		return x.Msg
	}
	return ""
}

func (m *SubTaskStatus) GetCheck() *CheckStatus {
	if x, ok := m.GetStatus().(*SubTaskStatus_Check); ok {
		return x.Check
	}
	return nil
}

func (m *SubTaskStatus) GetDump() *DumpStatus {
	if x, ok := m.GetStatus().(*SubTaskStatus_Dump); ok {
		return x.Dump
	}
	return nil
}

func (m *SubTaskStatus) GetLoad() *LoadStatus {
	if x, ok := m.GetStatus().(*SubTaskStatus_Load); ok {
		return x.Load
	}
	return nil
}

func (m *SubTaskStatus) GetSync() *SyncStatus {
	if x, ok := m.GetStatus().(*SubTaskStatus_Sync); ok {
		return x.Sync
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*SubTaskStatus) 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 _SubTaskStatus_OneofMarshaler, _SubTaskStatus_OneofUnmarshaler, _SubTaskStatus_OneofSizer, []interface{}{
		(*SubTaskStatus_Msg)(nil),
		(*SubTaskStatus_Check)(nil),
		(*SubTaskStatus_Dump)(nil),
		(*SubTaskStatus_Load)(nil),
		(*SubTaskStatus_Sync)(nil),
	}
}

func _SubTaskStatus_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SubTaskStatus)
	// status
	switch x := m.Status.(type) {
	case *SubTaskStatus_Msg:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		_ = b.EncodeStringBytes(x.Msg)
	case *SubTaskStatus_Check:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Check); err != nil {
			return err
		}
	case *SubTaskStatus_Dump:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Dump); err != nil {
			return err
		}
	case *SubTaskStatus_Load:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Load); err != nil {
			return err
		}
	case *SubTaskStatus_Sync:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sync); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("SubTaskStatus.Status has unexpected type %T", x)
	}
	return nil
}

func _SubTaskStatus_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SubTaskStatus)
	switch tag {
	case 6: // status.msg
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Status = &SubTaskStatus_Msg{x}
		return true, err
	case 7: // status.check
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CheckStatus)
		err := b.DecodeMessage(msg)
		m.Status = &SubTaskStatus_Check{msg}
		return true, err
	case 8: // status.dump
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DumpStatus)
		err := b.DecodeMessage(msg)
		m.Status = &SubTaskStatus_Dump{msg}
		return true, err
	case 9: // status.load
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LoadStatus)
		err := b.DecodeMessage(msg)
		m.Status = &SubTaskStatus_Load{msg}
		return true, err
	case 10: // status.sync
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SyncStatus)
		err := b.DecodeMessage(msg)
		m.Status = &SubTaskStatus_Sync{msg}
		return true, err
	default:
		return false, nil
	}
}

func _SubTaskStatus_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SubTaskStatus)
	// status
	switch x := m.Status.(type) {
	case *SubTaskStatus_Msg:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Msg)))
		n += len(x.Msg)
	case *SubTaskStatus_Check:
		s := proto.Size(x.Check)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SubTaskStatus_Dump:
		s := proto.Size(x.Dump)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SubTaskStatus_Load:
		s := proto.Size(x.Load)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SubTaskStatus_Sync:
		s := proto.Size(x.Sync)
		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
}

// SubTaskStatusList used for internal jsonpb marshal
type SubTaskStatusList struct {
	Status []*SubTaskStatus `protobuf:"bytes,1,rep,name=status,proto3" json:"status,omitempty"`
}

func (m *SubTaskStatusList) Reset()         { *m = SubTaskStatusList{} }
func (m *SubTaskStatusList) String() string { return proto.CompactTextString(m) }
func (*SubTaskStatusList) ProtoMessage()    {}
func (*SubTaskStatusList) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{21}
}
func (m *SubTaskStatusList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubTaskStatusList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubTaskStatusList.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 (m *SubTaskStatusList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubTaskStatusList.Merge(m, src)
}
func (m *SubTaskStatusList) XXX_Size() int {
	return m.Size()
}
func (m *SubTaskStatusList) XXX_DiscardUnknown() {
	xxx_messageInfo_SubTaskStatusList.DiscardUnknown(m)
}

var xxx_messageInfo_SubTaskStatusList proto.InternalMessageInfo

func (m *SubTaskStatusList) GetStatus() []*SubTaskStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

// CheckError represents error for check unit
// adds fields later
type CheckError struct {
	Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *CheckError) Reset()         { *m = CheckError{} }
func (m *CheckError) String() string { return proto.CompactTextString(m) }
func (*CheckError) ProtoMessage()    {}
func (*CheckError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{22}
}
func (m *CheckError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CheckError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CheckError.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 (m *CheckError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CheckError.Merge(m, src)
}
func (m *CheckError) XXX_Size() int {
	return m.Size()
}
func (m *CheckError) XXX_DiscardUnknown() {
	xxx_messageInfo_CheckError.DiscardUnknown(m)
}

var xxx_messageInfo_CheckError proto.InternalMessageInfo

func (m *CheckError) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// DumpError represents error for dump unit
// add fields later
type DumpError struct {
	Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *DumpError) Reset()         { *m = DumpError{} }
func (m *DumpError) String() string { return proto.CompactTextString(m) }
func (*DumpError) ProtoMessage()    {}
func (*DumpError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{23}
}
func (m *DumpError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DumpError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DumpError.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 (m *DumpError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DumpError.Merge(m, src)
}
func (m *DumpError) XXX_Size() int {
	return m.Size()
}
func (m *DumpError) XXX_DiscardUnknown() {
	xxx_messageInfo_DumpError.DiscardUnknown(m)
}

var xxx_messageInfo_DumpError proto.InternalMessageInfo

func (m *DumpError) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// LoadError represents error for load unit
type LoadError struct {
	Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *LoadError) Reset()         { *m = LoadError{} }
func (m *LoadError) String() string { return proto.CompactTextString(m) }
func (*LoadError) ProtoMessage()    {}
func (*LoadError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{24}
}
func (m *LoadError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LoadError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LoadError.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 (m *LoadError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadError.Merge(m, src)
}
func (m *LoadError) XXX_Size() int {
	return m.Size()
}
func (m *LoadError) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadError.DiscardUnknown(m)
}

var xxx_messageInfo_LoadError proto.InternalMessageInfo

func (m *LoadError) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// SyncSQLError represents a sql error in sync unit
type SyncSQLError struct {
	Msg                  string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	FailedBinlogPosition string `protobuf:"bytes,2,opt,name=failedBinlogPosition,proto3" json:"failedBinlogPosition,omitempty"`
	ErrorSQL             string `protobuf:"bytes,3,opt,name=errorSQL,proto3" json:"errorSQL,omitempty"`
}

func (m *SyncSQLError) Reset()         { *m = SyncSQLError{} }
func (m *SyncSQLError) String() string { return proto.CompactTextString(m) }
func (*SyncSQLError) ProtoMessage()    {}
func (*SyncSQLError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{25}
}
func (m *SyncSQLError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SyncSQLError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SyncSQLError.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 (m *SyncSQLError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncSQLError.Merge(m, src)
}
func (m *SyncSQLError) XXX_Size() int {
	return m.Size()
}
func (m *SyncSQLError) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncSQLError.DiscardUnknown(m)
}

var xxx_messageInfo_SyncSQLError proto.InternalMessageInfo

func (m *SyncSQLError) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *SyncSQLError) GetFailedBinlogPosition() string {
	if m != nil {
		return m.FailedBinlogPosition
	}
	return ""
}

func (m *SyncSQLError) GetErrorSQL() string {
	if m != nil {
		return m.ErrorSQL
	}
	return ""
}

// SyncError represents error list for sync unit
type SyncError struct {
	Errors []*SyncSQLError `protobuf:"bytes,1,rep,name=errors,proto3" json:"errors,omitempty"`
}

func (m *SyncError) Reset()         { *m = SyncError{} }
func (m *SyncError) String() string { return proto.CompactTextString(m) }
func (*SyncError) ProtoMessage()    {}
func (*SyncError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{26}
}
func (m *SyncError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SyncError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SyncError.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 (m *SyncError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncError.Merge(m, src)
}
func (m *SyncError) XXX_Size() int {
	return m.Size()
}
func (m *SyncError) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncError.DiscardUnknown(m)
}

var xxx_messageInfo_SyncError proto.InternalMessageInfo

func (m *SyncError) GetErrors() []*SyncSQLError {
	if m != nil {
		return m.Errors
	}
	return nil
}

// RelayError represents error for relay unit.
type RelayError struct {
	Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *RelayError) Reset()         { *m = RelayError{} }
func (m *RelayError) String() string { return proto.CompactTextString(m) }
func (*RelayError) ProtoMessage()    {}
func (*RelayError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{27}
}
func (m *RelayError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RelayError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RelayError.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 (m *RelayError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RelayError.Merge(m, src)
}
func (m *RelayError) XXX_Size() int {
	return m.Size()
}
func (m *RelayError) XXX_DiscardUnknown() {
	xxx_messageInfo_RelayError.DiscardUnknown(m)
}

var xxx_messageInfo_RelayError proto.InternalMessageInfo

func (m *RelayError) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// SubTaskError represents error for a sub task during running
// name: sub task'name, when starting a sub task the name should be unique
// stage: sub task's current stage
// unit: sub task's current dm unit's UnitType
// error: current unit's error information
//         for Sync, includes failed sql, failed sql pos in binlog, etc.
type SubTaskError struct {
	Name  string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Stage Stage    `protobuf:"varint,2,opt,name=stage,proto3,enum=pb.Stage" json:"stage,omitempty"`
	Unit  UnitType `protobuf:"varint,3,opt,name=unit,proto3,enum=pb.UnitType" json:"unit,omitempty"`
	// Types that are valid to be assigned to Error:
	//	*SubTaskError_Msg
	//	*SubTaskError_Check
	//	*SubTaskError_Dump
	//	*SubTaskError_Load
	//	*SubTaskError_Sync
	Error isSubTaskError_Error `protobuf_oneof:"error"`
}

func (m *SubTaskError) Reset()         { *m = SubTaskError{} }
func (m *SubTaskError) String() string { return proto.CompactTextString(m) }
func (*SubTaskError) ProtoMessage()    {}
func (*SubTaskError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{28}
}
func (m *SubTaskError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubTaskError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubTaskError.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 (m *SubTaskError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubTaskError.Merge(m, src)
}
func (m *SubTaskError) XXX_Size() int {
	return m.Size()
}
func (m *SubTaskError) XXX_DiscardUnknown() {
	xxx_messageInfo_SubTaskError.DiscardUnknown(m)
}

var xxx_messageInfo_SubTaskError proto.InternalMessageInfo

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

type SubTaskError_Msg struct {
	Msg string `protobuf:"bytes,4,opt,name=msg,proto3,oneof"`
}
type SubTaskError_Check struct {
	Check *CheckError `protobuf:"bytes,5,opt,name=check,proto3,oneof"`
}
type SubTaskError_Dump struct {
	Dump *DumpError `protobuf:"bytes,6,opt,name=dump,proto3,oneof"`
}
type SubTaskError_Load struct {
	Load *LoadError `protobuf:"bytes,7,opt,name=load,proto3,oneof"`
}
type SubTaskError_Sync struct {
	Sync *SyncError `protobuf:"bytes,8,opt,name=sync,proto3,oneof"`
}

func (*SubTaskError_Msg) isSubTaskError_Error()   {}
func (*SubTaskError_Check) isSubTaskError_Error() {}
func (*SubTaskError_Dump) isSubTaskError_Error()  {}
func (*SubTaskError_Load) isSubTaskError_Error()  {}
func (*SubTaskError_Sync) isSubTaskError_Error()  {}

func (m *SubTaskError) GetError() isSubTaskError_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *SubTaskError) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SubTaskError) GetStage() Stage {
	if m != nil {
		return m.Stage
	}
	return Stage_InvalidStage
}

func (m *SubTaskError) GetUnit() UnitType {
	if m != nil {
		return m.Unit
	}
	return UnitType_InvalidUnit
}

func (m *SubTaskError) GetMsg() string {
	if x, ok := m.GetError().(*SubTaskError_Msg); ok {
		return x.Msg
	}
	return ""
}

func (m *SubTaskError) GetCheck() *CheckError {
	if x, ok := m.GetError().(*SubTaskError_Check); ok {
		return x.Check
	}
	return nil
}

func (m *SubTaskError) GetDump() *DumpError {
	if x, ok := m.GetError().(*SubTaskError_Dump); ok {
		return x.Dump
	}
	return nil
}

func (m *SubTaskError) GetLoad() *LoadError {
	if x, ok := m.GetError().(*SubTaskError_Load); ok {
		return x.Load
	}
	return nil
}

func (m *SubTaskError) GetSync() *SyncError {
	if x, ok := m.GetError().(*SubTaskError_Sync); ok {
		return x.Sync
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*SubTaskError) 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 _SubTaskError_OneofMarshaler, _SubTaskError_OneofUnmarshaler, _SubTaskError_OneofSizer, []interface{}{
		(*SubTaskError_Msg)(nil),
		(*SubTaskError_Check)(nil),
		(*SubTaskError_Dump)(nil),
		(*SubTaskError_Load)(nil),
		(*SubTaskError_Sync)(nil),
	}
}

func _SubTaskError_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SubTaskError)
	// error
	switch x := m.Error.(type) {
	case *SubTaskError_Msg:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		_ = b.EncodeStringBytes(x.Msg)
	case *SubTaskError_Check:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Check); err != nil {
			return err
		}
	case *SubTaskError_Dump:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Dump); err != nil {
			return err
		}
	case *SubTaskError_Load:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Load); err != nil {
			return err
		}
	case *SubTaskError_Sync:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sync); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("SubTaskError.Error has unexpected type %T", x)
	}
	return nil
}

func _SubTaskError_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SubTaskError)
	switch tag {
	case 4: // error.msg
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Error = &SubTaskError_Msg{x}
		return true, err
	case 5: // error.check
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CheckError)
		err := b.DecodeMessage(msg)
		m.Error = &SubTaskError_Check{msg}
		return true, err
	case 6: // error.dump
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DumpError)
		err := b.DecodeMessage(msg)
		m.Error = &SubTaskError_Dump{msg}
		return true, err
	case 7: // error.load
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LoadError)
		err := b.DecodeMessage(msg)
		m.Error = &SubTaskError_Load{msg}
		return true, err
	case 8: // error.sync
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SyncError)
		err := b.DecodeMessage(msg)
		m.Error = &SubTaskError_Sync{msg}
		return true, err
	default:
		return false, nil
	}
}

func _SubTaskError_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SubTaskError)
	// error
	switch x := m.Error.(type) {
	case *SubTaskError_Msg:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Msg)))
		n += len(x.Msg)
	case *SubTaskError_Check:
		s := proto.Size(x.Check)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SubTaskError_Dump:
		s := proto.Size(x.Dump)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SubTaskError_Load:
		s := proto.Size(x.Load)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *SubTaskError_Sync:
		s := proto.Size(x.Sync)
		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
}

// SubTaskErrorList used for internal jsonpb marshal
type SubTaskErrorList struct {
	Error []*SubTaskError `protobuf:"bytes,1,rep,name=error,proto3" json:"error,omitempty"`
}

func (m *SubTaskErrorList) Reset()         { *m = SubTaskErrorList{} }
func (m *SubTaskErrorList) String() string { return proto.CompactTextString(m) }
func (*SubTaskErrorList) ProtoMessage()    {}
func (*SubTaskErrorList) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{29}
}
func (m *SubTaskErrorList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SubTaskErrorList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SubTaskErrorList.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 (m *SubTaskErrorList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubTaskErrorList.Merge(m, src)
}
func (m *SubTaskErrorList) XXX_Size() int {
	return m.Size()
}
func (m *SubTaskErrorList) XXX_DiscardUnknown() {
	xxx_messageInfo_SubTaskErrorList.DiscardUnknown(m)
}

var xxx_messageInfo_SubTaskErrorList proto.InternalMessageInfo

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

// ProcessResult represents results produced by a dm unit
// isCanceled: indicates whether the process is canceled from external
//             when Stop or Pause is requested from external, isCanceled will be true
// errors: includes all (potential) errors occured when processing
type ProcessResult struct {
	IsCanceled bool            `protobuf:"varint,1,opt,name=isCanceled,proto3" json:"isCanceled,omitempty"`
	Errors     []*ProcessError `protobuf:"bytes,2,rep,name=errors,proto3" json:"errors,omitempty"`
	Detail     []byte          `protobuf:"bytes,3,opt,name=detail,proto3" json:"detail,omitempty"`
}

func (m *ProcessResult) Reset()         { *m = ProcessResult{} }
func (m *ProcessResult) String() string { return proto.CompactTextString(m) }
func (*ProcessResult) ProtoMessage()    {}
func (*ProcessResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{30}
}
func (m *ProcessResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProcessResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProcessResult.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 (m *ProcessResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessResult.Merge(m, src)
}
func (m *ProcessResult) XXX_Size() int {
	return m.Size()
}
func (m *ProcessResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessResult.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessResult proto.InternalMessageInfo

func (m *ProcessResult) GetIsCanceled() bool {
	if m != nil {
		return m.IsCanceled
	}
	return false
}

func (m *ProcessResult) GetErrors() []*ProcessError {
	if m != nil {
		return m.Errors
	}
	return nil
}

func (m *ProcessResult) GetDetail() []byte {
	if m != nil {
		return m.Detail
	}
	return nil
}

// ProcessError represents error produced by a dm unit
// NOTE: refine later, like add error scope field
type ProcessError struct {
	Type ErrorType `protobuf:"varint,1,opt,name=Type,proto3,enum=pb.ErrorType" json:"Type,omitempty"`
	Msg  string    `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *ProcessError) Reset()         { *m = ProcessError{} }
func (m *ProcessError) String() string { return proto.CompactTextString(m) }
func (*ProcessError) ProtoMessage()    {}
func (*ProcessError) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{31}
}
func (m *ProcessError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProcessError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProcessError.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 (m *ProcessError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessError.Merge(m, src)
}
func (m *ProcessError) XXX_Size() int {
	return m.Size()
}
func (m *ProcessError) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessError.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessError proto.InternalMessageInfo

func (m *ProcessError) GetType() ErrorType {
	if m != nil {
		return m.Type
	}
	return ErrorType_UnknownError
}

func (m *ProcessError) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// DDLInfo represents a occurred DDL in a sub task
// it been sent from dm-worker to dm-master
// dm-master uses it to contruct a DDL lock and do syncing with other dm-workers
// add more fields if needed
type DDLInfo struct {
	Task   string   `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	Schema string   `protobuf:"bytes,2,opt,name=schema,proto3" json:"schema,omitempty"`
	Table  string   `protobuf:"bytes,3,opt,name=table,proto3" json:"table,omitempty"`
	DDLs   []string `protobuf:"bytes,4,rep,name=DDLs,proto3" json:"DDLs,omitempty"`
}

func (m *DDLInfo) Reset()         { *m = DDLInfo{} }
func (m *DDLInfo) String() string { return proto.CompactTextString(m) }
func (*DDLInfo) ProtoMessage()    {}
func (*DDLInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{32}
}
func (m *DDLInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DDLInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DDLInfo.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 (m *DDLInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DDLInfo.Merge(m, src)
}
func (m *DDLInfo) XXX_Size() int {
	return m.Size()
}
func (m *DDLInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_DDLInfo.DiscardUnknown(m)
}

var xxx_messageInfo_DDLInfo proto.InternalMessageInfo

func (m *DDLInfo) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

func (m *DDLInfo) GetSchema() string {
	if m != nil {
		return m.Schema
	}
	return ""
}

func (m *DDLInfo) GetTable() string {
	if m != nil {
		return m.Table
	}
	return ""
}

func (m *DDLInfo) GetDDLs() []string {
	if m != nil {
		return m.DDLs
	}
	return nil
}

// DDLLockInfo represents a DDL lock
// it been sent from dm-master to dm-worker
// add more fields if needed
type DDLLockInfo struct {
	Task string `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ID   string `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

func (m *DDLLockInfo) Reset()         { *m = DDLLockInfo{} }
func (m *DDLLockInfo) String() string { return proto.CompactTextString(m) }
func (*DDLLockInfo) ProtoMessage()    {}
func (*DDLLockInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{33}
}
func (m *DDLLockInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DDLLockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DDLLockInfo.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 (m *DDLLockInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DDLLockInfo.Merge(m, src)
}
func (m *DDLLockInfo) XXX_Size() int {
	return m.Size()
}
func (m *DDLLockInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_DDLLockInfo.DiscardUnknown(m)
}

var xxx_messageInfo_DDLLockInfo proto.InternalMessageInfo

func (m *DDLLockInfo) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

func (m *DDLLockInfo) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

// ExecDDLRequest represents a request for a dm-worker to execute (or ignore) a DDL
type ExecDDLRequest struct {
	Task     string `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	LockID   string `protobuf:"bytes,2,opt,name=lockID,proto3" json:"lockID,omitempty"`
	Exec     bool   `protobuf:"varint,3,opt,name=exec,proto3" json:"exec,omitempty"`
	TraceGID string `protobuf:"bytes,4,opt,name=traceGID,proto3" json:"traceGID,omitempty"`
}

func (m *ExecDDLRequest) Reset()         { *m = ExecDDLRequest{} }
func (m *ExecDDLRequest) String() string { return proto.CompactTextString(m) }
func (*ExecDDLRequest) ProtoMessage()    {}
func (*ExecDDLRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{34}
}
func (m *ExecDDLRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecDDLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecDDLRequest.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 (m *ExecDDLRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecDDLRequest.Merge(m, src)
}
func (m *ExecDDLRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExecDDLRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecDDLRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExecDDLRequest proto.InternalMessageInfo

func (m *ExecDDLRequest) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

func (m *ExecDDLRequest) GetLockID() string {
	if m != nil {
		return m.LockID
	}
	return ""
}

func (m *ExecDDLRequest) GetExec() bool {
	if m != nil {
		return m.Exec
	}
	return false
}

func (m *ExecDDLRequest) GetTraceGID() string {
	if m != nil {
		return m.TraceGID
	}
	return ""
}

// BreakDDLLockRequest represents a request for a dm-worker to force to break the DDL lock
// task: sub task's name
// removeLockID: DDLLockInfo's ID which need to remove
// execDDL: execute DDL which is blocking
// skipDDL: skip DDL which is blocking
// execDDL and skipDDL can not specify both at the same time, but can specify neither
type BreakDDLLockRequest struct {
	Task         string `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	RemoveLockID string `protobuf:"bytes,2,opt,name=removeLockID,proto3" json:"removeLockID,omitempty"`
	ExecDDL      bool   `protobuf:"varint,3,opt,name=execDDL,proto3" json:"execDDL,omitempty"`
	SkipDDL      bool   `protobuf:"varint,4,opt,name=skipDDL,proto3" json:"skipDDL,omitempty"`
}

func (m *BreakDDLLockRequest) Reset()         { *m = BreakDDLLockRequest{} }
func (m *BreakDDLLockRequest) String() string { return proto.CompactTextString(m) }
func (*BreakDDLLockRequest) ProtoMessage()    {}
func (*BreakDDLLockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{35}
}
func (m *BreakDDLLockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BreakDDLLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BreakDDLLockRequest.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 (m *BreakDDLLockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BreakDDLLockRequest.Merge(m, src)
}
func (m *BreakDDLLockRequest) XXX_Size() int {
	return m.Size()
}
func (m *BreakDDLLockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BreakDDLLockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BreakDDLLockRequest proto.InternalMessageInfo

func (m *BreakDDLLockRequest) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

func (m *BreakDDLLockRequest) GetRemoveLockID() string {
	if m != nil {
		return m.RemoveLockID
	}
	return ""
}

func (m *BreakDDLLockRequest) GetExecDDL() bool {
	if m != nil {
		return m.ExecDDL
	}
	return false
}

func (m *BreakDDLLockRequest) GetSkipDDL() bool {
	if m != nil {
		return m.SkipDDL
	}
	return false
}

// SwitchRelayMasterRequest represents a request for switching a dm-worker's relay unit to another master server
type SwitchRelayMasterRequest struct {
}

func (m *SwitchRelayMasterRequest) Reset()         { *m = SwitchRelayMasterRequest{} }
func (m *SwitchRelayMasterRequest) String() string { return proto.CompactTextString(m) }
func (*SwitchRelayMasterRequest) ProtoMessage()    {}
func (*SwitchRelayMasterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{36}
}
func (m *SwitchRelayMasterRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SwitchRelayMasterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SwitchRelayMasterRequest.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 (m *SwitchRelayMasterRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SwitchRelayMasterRequest.Merge(m, src)
}
func (m *SwitchRelayMasterRequest) XXX_Size() int {
	return m.Size()
}
func (m *SwitchRelayMasterRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SwitchRelayMasterRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SwitchRelayMasterRequest proto.InternalMessageInfo

// OperateRelayRequest represents a request for operate relay unit
type OperateRelayRequest struct {
	Op RelayOp `protobuf:"varint,1,opt,name=op,proto3,enum=pb.RelayOp" json:"op,omitempty"`
}

func (m *OperateRelayRequest) Reset()         { *m = OperateRelayRequest{} }
func (m *OperateRelayRequest) String() string { return proto.CompactTextString(m) }
func (*OperateRelayRequest) ProtoMessage()    {}
func (*OperateRelayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{37}
}
func (m *OperateRelayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OperateRelayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OperateRelayRequest.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 (m *OperateRelayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OperateRelayRequest.Merge(m, src)
}
func (m *OperateRelayRequest) XXX_Size() int {
	return m.Size()
}
func (m *OperateRelayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_OperateRelayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_OperateRelayRequest proto.InternalMessageInfo

func (m *OperateRelayRequest) GetOp() RelayOp {
	if m != nil {
		return m.Op
	}
	return RelayOp_InvalidRelayOp
}

type OperateRelayResponse struct {
	Op     RelayOp `protobuf:"varint,1,opt,name=op,proto3,enum=pb.RelayOp" json:"op,omitempty"`
	Result bool    `protobuf:"varint,2,opt,name=result,proto3" json:"result,omitempty"`
	Worker string  `protobuf:"bytes,3,opt,name=worker,proto3" json:"worker,omitempty"`
	Msg    string  `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *OperateRelayResponse) Reset()         { *m = OperateRelayResponse{} }
func (m *OperateRelayResponse) String() string { return proto.CompactTextString(m) }
func (*OperateRelayResponse) ProtoMessage()    {}
func (*OperateRelayResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{38}
}
func (m *OperateRelayResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OperateRelayResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OperateRelayResponse.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 (m *OperateRelayResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OperateRelayResponse.Merge(m, src)
}
func (m *OperateRelayResponse) XXX_Size() int {
	return m.Size()
}
func (m *OperateRelayResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_OperateRelayResponse.DiscardUnknown(m)
}

var xxx_messageInfo_OperateRelayResponse proto.InternalMessageInfo

func (m *OperateRelayResponse) GetOp() RelayOp {
	if m != nil {
		return m.Op
	}
	return RelayOp_InvalidRelayOp
}

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

func (m *OperateRelayResponse) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

func (m *OperateRelayResponse) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

// PurgeRelayRequest represents a request to purge relay log files for this dm-worker
// inactive: whether purge inactive relay log files
// time: whether purge relay log files before this time, the number of seconds elapsed since January 1, 1970 UTC
// filename: whether purge relay log files before this filename
// subDir: specify relay sub directory for @filename
type PurgeRelayRequest struct {
	Inactive bool   `protobuf:"varint,1,opt,name=inactive,proto3" json:"inactive,omitempty"`
	Time     int64  `protobuf:"varint,2,opt,name=time,proto3" json:"time,omitempty"`
	Filename string `protobuf:"bytes,3,opt,name=filename,proto3" json:"filename,omitempty"`
	SubDir   string `protobuf:"bytes,4,opt,name=subDir,proto3" json:"subDir,omitempty"`
}

func (m *PurgeRelayRequest) Reset()         { *m = PurgeRelayRequest{} }
func (m *PurgeRelayRequest) String() string { return proto.CompactTextString(m) }
func (*PurgeRelayRequest) ProtoMessage()    {}
func (*PurgeRelayRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{39}
}
func (m *PurgeRelayRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PurgeRelayRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PurgeRelayRequest.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 (m *PurgeRelayRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PurgeRelayRequest.Merge(m, src)
}
func (m *PurgeRelayRequest) XXX_Size() int {
	return m.Size()
}
func (m *PurgeRelayRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PurgeRelayRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PurgeRelayRequest proto.InternalMessageInfo

func (m *PurgeRelayRequest) GetInactive() bool {
	if m != nil {
		return m.Inactive
	}
	return false
}

func (m *PurgeRelayRequest) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *PurgeRelayRequest) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

func (m *PurgeRelayRequest) GetSubDir() string {
	if m != nil {
		return m.SubDir
	}
	return ""
}

type QueryWorkerConfigRequest struct {
}

func (m *QueryWorkerConfigRequest) Reset()         { *m = QueryWorkerConfigRequest{} }
func (m *QueryWorkerConfigRequest) String() string { return proto.CompactTextString(m) }
func (*QueryWorkerConfigRequest) ProtoMessage()    {}
func (*QueryWorkerConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{40}
}
func (m *QueryWorkerConfigRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryWorkerConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryWorkerConfigRequest.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 (m *QueryWorkerConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryWorkerConfigRequest.Merge(m, src)
}
func (m *QueryWorkerConfigRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryWorkerConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryWorkerConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryWorkerConfigRequest proto.InternalMessageInfo

type QueryWorkerConfigResponse struct {
	Result   bool   `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
	Worker   string `protobuf:"bytes,2,opt,name=worker,proto3" json:"worker,omitempty"`
	Msg      string `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	SourceID string `protobuf:"bytes,4,opt,name=sourceID,proto3" json:"sourceID,omitempty"`
	Content  string `protobuf:"bytes,5,opt,name=content,proto3" json:"content,omitempty"`
}

func (m *QueryWorkerConfigResponse) Reset()         { *m = QueryWorkerConfigResponse{} }
func (m *QueryWorkerConfigResponse) String() string { return proto.CompactTextString(m) }
func (*QueryWorkerConfigResponse) ProtoMessage()    {}
func (*QueryWorkerConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{41}
}
func (m *QueryWorkerConfigResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryWorkerConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryWorkerConfigResponse.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 (m *QueryWorkerConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryWorkerConfigResponse.Merge(m, src)
}
func (m *QueryWorkerConfigResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryWorkerConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryWorkerConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryWorkerConfigResponse proto.InternalMessageInfo

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

func (m *QueryWorkerConfigResponse) GetWorker() string {
	if m != nil {
		return m.Worker
	}
	return ""
}

func (m *QueryWorkerConfigResponse) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *QueryWorkerConfigResponse) GetSourceID() string {
	if m != nil {
		return m.SourceID
	}
	return ""
}

func (m *QueryWorkerConfigResponse) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type TaskMeta struct {
	Op    TaskOp `protobuf:"varint,1,opt,name=op,proto3,enum=pb.TaskOp" json:"op,omitempty"`
	Stage Stage  `protobuf:"varint,2,opt,name=stage,proto3,enum=pb.Stage" json:"stage,omitempty"`
	Name  string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Task  []byte `protobuf:"bytes,4,opt,name=task,proto3" json:"task,omitempty"`
}

func (m *TaskMeta) Reset()         { *m = TaskMeta{} }
func (m *TaskMeta) String() string { return proto.CompactTextString(m) }
func (*TaskMeta) ProtoMessage()    {}
func (*TaskMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{42}
}
func (m *TaskMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaskMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaskMeta.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 (m *TaskMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskMeta.Merge(m, src)
}
func (m *TaskMeta) XXX_Size() int {
	return m.Size()
}
func (m *TaskMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskMeta.DiscardUnknown(m)
}

var xxx_messageInfo_TaskMeta proto.InternalMessageInfo

func (m *TaskMeta) GetOp() TaskOp {
	if m != nil {
		return m.Op
	}
	return TaskOp_InvalidOp
}

func (m *TaskMeta) GetStage() Stage {
	if m != nil {
		return m.Stage
	}
	return Stage_InvalidStage
}

func (m *TaskMeta) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TaskMeta) GetTask() []byte {
	if m != nil {
		return m.Task
	}
	return nil
}

type TaskLog struct {
	Id   int64     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Task *TaskMeta `protobuf:"bytes,2,opt,name=task,proto3" json:"task,omitempty"`
	Ts   int64     `protobuf:"varint,3,opt,name=ts,proto3" json:"ts,omitempty"`
	// true means this log is applied successfully
	Success bool   `protobuf:"varint,4,opt,name=success,proto3" json:"success,omitempty"`
	Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *TaskLog) Reset()         { *m = TaskLog{} }
func (m *TaskLog) String() string { return proto.CompactTextString(m) }
func (*TaskLog) ProtoMessage()    {}
func (*TaskLog) Descriptor() ([]byte, []int) {
	return fileDescriptor_51a1b9e17fd67b10, []int{43}
}
func (m *TaskLog) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TaskLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TaskLog.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 (m *TaskLog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskLog.Merge(m, src)
}
func (m *TaskLog) XXX_Size() int {
	return m.Size()
}
func (m *TaskLog) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskLog.DiscardUnknown(m)
}

var xxx_messageInfo_TaskLog proto.InternalMessageInfo

func (m *TaskLog) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *TaskLog) GetTask() *TaskMeta {
	if m != nil {
		return m.Task
	}
	return nil
}

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

func (m *TaskLog) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func (m *TaskLog) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func init() {
	proto.RegisterEnum("pb.TaskOp", TaskOp_name, TaskOp_value)
	proto.RegisterEnum("pb.SQLOp", SQLOp_name, SQLOp_value)
	proto.RegisterEnum("pb.Stage", Stage_name, Stage_value)
	proto.RegisterEnum("pb.UnitType", UnitType_name, UnitType_value)
	proto.RegisterEnum("pb.ErrorType", ErrorType_name, ErrorType_value)
	proto.RegisterEnum("pb.RelayOp", RelayOp_name, RelayOp_value)
	proto.RegisterType((*StartSubTaskRequest)(nil), "pb.StartSubTaskRequest")
	proto.RegisterType((*UpdateRelayRequest)(nil), "pb.UpdateRelayRequest")
	proto.RegisterType((*MigrateRelayRequest)(nil), "pb.MigrateRelayRequest")
	proto.RegisterType((*OperateSubTaskRequest)(nil), "pb.OperateSubTaskRequest")
	proto.RegisterType((*OperateSubTaskResponse)(nil), "pb.OperateSubTaskResponse")
	proto.RegisterType((*QueryTaskOperationRequest)(nil), "pb.QueryTaskOperationRequest")
	proto.RegisterType((*QueryTaskOperationResponse)(nil), "pb.QueryTaskOperationResponse")
	proto.RegisterType((*UpdateSubTaskRequest)(nil), "pb.UpdateSubTaskRequest")
	proto.RegisterType((*QueryStatusRequest)(nil), "pb.QueryStatusRequest")
	proto.RegisterType((*QueryErrorRequest)(nil), "pb.QueryErrorRequest")
	proto.RegisterType((*HandleSubTaskSQLsRequest)(nil), "pb.HandleSubTaskSQLsRequest")
	proto.RegisterType((*CommonWorkerResponse)(nil), "pb.CommonWorkerResponse")
	proto.RegisterType((*QueryStatusResponse)(nil), "pb.QueryStatusResponse")
	proto.RegisterType((*QueryErrorResponse)(nil), "pb.QueryErrorResponse")
	proto.RegisterType((*CheckStatus)(nil), "pb.CheckStatus")
	proto.RegisterType((*DumpStatus)(nil), "pb.DumpStatus")
	proto.RegisterType((*LoadStatus)(nil), "pb.LoadStatus")
	proto.RegisterType((*ShardingGroup)(nil), "pb.ShardingGroup")
	proto.RegisterType((*SyncStatus)(nil), "pb.SyncStatus")
	proto.RegisterType((*RelayStatus)(nil), "pb.RelayStatus")
	proto.RegisterType((*SubTaskStatus)(nil), "pb.SubTaskStatus")
	proto.RegisterType((*SubTaskStatusList)(nil), "pb.SubTaskStatusList")
	proto.RegisterType((*CheckError)(nil), "pb.CheckError")
	proto.RegisterType((*DumpError)(nil), "pb.DumpError")
	proto.RegisterType((*LoadError)(nil), "pb.LoadError")
	proto.RegisterType((*SyncSQLError)(nil), "pb.SyncSQLError")
	proto.RegisterType((*SyncError)(nil), "pb.SyncError")
	proto.RegisterType((*RelayError)(nil), "pb.RelayError")
	proto.RegisterType((*SubTaskError)(nil), "pb.SubTaskError")
	proto.RegisterType((*SubTaskErrorList)(nil), "pb.SubTaskErrorList")
	proto.RegisterType((*ProcessResult)(nil), "pb.ProcessResult")
	proto.RegisterType((*ProcessError)(nil), "pb.ProcessError")
	proto.RegisterType((*DDLInfo)(nil), "pb.DDLInfo")
	proto.RegisterType((*DDLLockInfo)(nil), "pb.DDLLockInfo")
	proto.RegisterType((*ExecDDLRequest)(nil), "pb.ExecDDLRequest")
	proto.RegisterType((*BreakDDLLockRequest)(nil), "pb.BreakDDLLockRequest")
	proto.RegisterType((*SwitchRelayMasterRequest)(nil), "pb.SwitchRelayMasterRequest")
	proto.RegisterType((*OperateRelayRequest)(nil), "pb.OperateRelayRequest")
	proto.RegisterType((*OperateRelayResponse)(nil), "pb.OperateRelayResponse")
	proto.RegisterType((*PurgeRelayRequest)(nil), "pb.PurgeRelayRequest")
	proto.RegisterType((*QueryWorkerConfigRequest)(nil), "pb.QueryWorkerConfigRequest")
	proto.RegisterType((*QueryWorkerConfigResponse)(nil), "pb.QueryWorkerConfigResponse")
	proto.RegisterType((*TaskMeta)(nil), "pb.TaskMeta")
	proto.RegisterType((*TaskLog)(nil), "pb.TaskLog")
}

func init() { proto.RegisterFile("dmworker.proto", fileDescriptor_51a1b9e17fd67b10) }

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

// 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

// WorkerClient is the client API for Worker service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type WorkerClient interface {
	StartSubTask(ctx context.Context, in *StartSubTaskRequest, opts ...grpc.CallOption) (*OperateSubTaskResponse, error)
	OperateSubTask(ctx context.Context, in *OperateSubTaskRequest, opts ...grpc.CallOption) (*OperateSubTaskResponse, error)
	UpdateSubTask(ctx context.Context, in *UpdateSubTaskRequest, opts ...grpc.CallOption) (*OperateSubTaskResponse, error)
	QueryStatus(ctx context.Context, in *QueryStatusRequest, opts ...grpc.CallOption) (*QueryStatusResponse, error)
	QueryError(ctx context.Context, in *QueryErrorRequest, opts ...grpc.CallOption) (*QueryErrorResponse, error)
	QueryTaskOperation(ctx context.Context, in *QueryTaskOperationRequest, opts ...grpc.CallOption) (*QueryTaskOperationResponse, error)
	HandleSQLs(ctx context.Context, in *HandleSubTaskSQLsRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
	// FetchDDLInfo fetches DDL info from dm-worker by dm-master
	// and sends the relevant DDL lock info back to dm-worker
	// NOTE: split to two RPCs if needed
	FetchDDLInfo(ctx context.Context, opts ...grpc.CallOption) (Worker_FetchDDLInfoClient, error)
	// ExecuteDDL request a dm-worker to execute or ignore (skip) a DDL
	ExecuteDDL(ctx context.Context, in *ExecDDLRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
	// BreakDDLLock request a dm-worker to break a DDL lock
	// including remove DDLLockInfo and/or execute/skip DDL
	BreakDDLLock(ctx context.Context, in *BreakDDLLockRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
	// SwitchRelayMaster request a dm-worker's relay unit switching to another master server
	SwitchRelayMaster(ctx context.Context, in *SwitchRelayMasterRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
	// OperateRelay operates relay unit
	// differ from SwitchRelayMaster which may add more args in the future
	OperateRelay(ctx context.Context, in *OperateRelayRequest, opts ...grpc.CallOption) (*OperateRelayResponse, error)
	// PurgeRelay purges relay log files for this dm-worker
	PurgeRelay(ctx context.Context, in *PurgeRelayRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
	UpdateRelayConfig(ctx context.Context, in *UpdateRelayRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
	QueryWorkerConfig(ctx context.Context, in *QueryWorkerConfigRequest, opts ...grpc.CallOption) (*QueryWorkerConfigResponse, error)
	MigrateRelay(ctx context.Context, in *MigrateRelayRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error)
}

type workerClient struct {
	cc *grpc.ClientConn
}

func NewWorkerClient(cc *grpc.ClientConn) WorkerClient {
	return &workerClient{cc}
}

func (c *workerClient) StartSubTask(ctx context.Context, in *StartSubTaskRequest, opts ...grpc.CallOption) (*OperateSubTaskResponse, error) {
	out := new(OperateSubTaskResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/StartSubTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) OperateSubTask(ctx context.Context, in *OperateSubTaskRequest, opts ...grpc.CallOption) (*OperateSubTaskResponse, error) {
	out := new(OperateSubTaskResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/OperateSubTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) UpdateSubTask(ctx context.Context, in *UpdateSubTaskRequest, opts ...grpc.CallOption) (*OperateSubTaskResponse, error) {
	out := new(OperateSubTaskResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/UpdateSubTask", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) QueryStatus(ctx context.Context, in *QueryStatusRequest, opts ...grpc.CallOption) (*QueryStatusResponse, error) {
	out := new(QueryStatusResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/QueryStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) QueryError(ctx context.Context, in *QueryErrorRequest, opts ...grpc.CallOption) (*QueryErrorResponse, error) {
	out := new(QueryErrorResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/QueryError", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) QueryTaskOperation(ctx context.Context, in *QueryTaskOperationRequest, opts ...grpc.CallOption) (*QueryTaskOperationResponse, error) {
	out := new(QueryTaskOperationResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/QueryTaskOperation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) HandleSQLs(ctx context.Context, in *HandleSubTaskSQLsRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/HandleSQLs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) FetchDDLInfo(ctx context.Context, opts ...grpc.CallOption) (Worker_FetchDDLInfoClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Worker_serviceDesc.Streams[0], "/pb.Worker/FetchDDLInfo", opts...)
	if err != nil {
		return nil, err
	}
	x := &workerFetchDDLInfoClient{stream}
	return x, nil
}

type Worker_FetchDDLInfoClient interface {
	Send(*DDLLockInfo) error
	Recv() (*DDLInfo, error)
	grpc.ClientStream
}

type workerFetchDDLInfoClient struct {
	grpc.ClientStream
}

func (x *workerFetchDDLInfoClient) Send(m *DDLLockInfo) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *workerClient) ExecuteDDL(ctx context.Context, in *ExecDDLRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/ExecuteDDL", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) BreakDDLLock(ctx context.Context, in *BreakDDLLockRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/BreakDDLLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) SwitchRelayMaster(ctx context.Context, in *SwitchRelayMasterRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/SwitchRelayMaster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) OperateRelay(ctx context.Context, in *OperateRelayRequest, opts ...grpc.CallOption) (*OperateRelayResponse, error) {
	out := new(OperateRelayResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/OperateRelay", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) PurgeRelay(ctx context.Context, in *PurgeRelayRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/PurgeRelay", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) UpdateRelayConfig(ctx context.Context, in *UpdateRelayRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/UpdateRelayConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) QueryWorkerConfig(ctx context.Context, in *QueryWorkerConfigRequest, opts ...grpc.CallOption) (*QueryWorkerConfigResponse, error) {
	out := new(QueryWorkerConfigResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/QueryWorkerConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *workerClient) MigrateRelay(ctx context.Context, in *MigrateRelayRequest, opts ...grpc.CallOption) (*CommonWorkerResponse, error) {
	out := new(CommonWorkerResponse)
	err := c.cc.Invoke(ctx, "/pb.Worker/MigrateRelay", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WorkerServer is the server API for Worker service.
type WorkerServer interface {
	StartSubTask(context.Context, *StartSubTaskRequest) (*OperateSubTaskResponse, error)
	OperateSubTask(context.Context, *OperateSubTaskRequest) (*OperateSubTaskResponse, error)
	UpdateSubTask(context.Context, *UpdateSubTaskRequest) (*OperateSubTaskResponse, error)
	QueryStatus(context.Context, *QueryStatusRequest) (*QueryStatusResponse, error)
	QueryError(context.Context, *QueryErrorRequest) (*QueryErrorResponse, error)
	QueryTaskOperation(context.Context, *QueryTaskOperationRequest) (*QueryTaskOperationResponse, error)
	HandleSQLs(context.Context, *HandleSubTaskSQLsRequest) (*CommonWorkerResponse, error)
	// FetchDDLInfo fetches DDL info from dm-worker by dm-master
	// and sends the relevant DDL lock info back to dm-worker
	// NOTE: split to two RPCs if needed
	FetchDDLInfo(Worker_FetchDDLInfoServer) error
	// ExecuteDDL request a dm-worker to execute or ignore (skip) a DDL
	ExecuteDDL(context.Context, *ExecDDLRequest) (*CommonWorkerResponse, error)
	// BreakDDLLock request a dm-worker to break a DDL lock
	// including remove DDLLockInfo and/or execute/skip DDL
	BreakDDLLock(context.Context, *BreakDDLLockRequest) (*CommonWorkerResponse, error)
	// SwitchRelayMaster request a dm-worker's relay unit switching to another master server
	SwitchRelayMaster(context.Context, *SwitchRelayMasterRequest) (*CommonWorkerResponse, error)
	// OperateRelay operates relay unit
	// differ from SwitchRelayMaster which may add more args in the future
	OperateRelay(context.Context, *OperateRelayRequest) (*OperateRelayResponse, error)
	// PurgeRelay purges relay log files for this dm-worker
	PurgeRelay(context.Context, *PurgeRelayRequest) (*CommonWorkerResponse, error)
	UpdateRelayConfig(context.Context, *UpdateRelayRequest) (*CommonWorkerResponse, error)
	QueryWorkerConfig(context.Context, *QueryWorkerConfigRequest) (*QueryWorkerConfigResponse, error)
	MigrateRelay(context.Context, *MigrateRelayRequest) (*CommonWorkerResponse, error)
}

func RegisterWorkerServer(s *grpc.Server, srv WorkerServer) {
	s.RegisterService(&_Worker_serviceDesc, srv)
}

func _Worker_StartSubTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartSubTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).StartSubTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/StartSubTask",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).StartSubTask(ctx, req.(*StartSubTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_OperateSubTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OperateSubTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).OperateSubTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/OperateSubTask",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).OperateSubTask(ctx, req.(*OperateSubTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_UpdateSubTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSubTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).UpdateSubTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/UpdateSubTask",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).UpdateSubTask(ctx, req.(*UpdateSubTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_QueryStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).QueryStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/QueryStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).QueryStatus(ctx, req.(*QueryStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_QueryError_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryErrorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).QueryError(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/QueryError",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).QueryError(ctx, req.(*QueryErrorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_QueryTaskOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTaskOperationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).QueryTaskOperation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/QueryTaskOperation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).QueryTaskOperation(ctx, req.(*QueryTaskOperationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_HandleSQLs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HandleSubTaskSQLsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).HandleSQLs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/HandleSQLs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).HandleSQLs(ctx, req.(*HandleSubTaskSQLsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_FetchDDLInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(WorkerServer).FetchDDLInfo(&workerFetchDDLInfoServer{stream})
}

type Worker_FetchDDLInfoServer interface {
	Send(*DDLInfo) error
	Recv() (*DDLLockInfo, error)
	grpc.ServerStream
}

type workerFetchDDLInfoServer struct {
	grpc.ServerStream
}

func (x *workerFetchDDLInfoServer) Send(m *DDLInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Worker_ExecuteDDL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecDDLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).ExecuteDDL(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/ExecuteDDL",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).ExecuteDDL(ctx, req.(*ExecDDLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_BreakDDLLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BreakDDLLockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).BreakDDLLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/BreakDDLLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).BreakDDLLock(ctx, req.(*BreakDDLLockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_SwitchRelayMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SwitchRelayMasterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).SwitchRelayMaster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/SwitchRelayMaster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).SwitchRelayMaster(ctx, req.(*SwitchRelayMasterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_OperateRelay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OperateRelayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).OperateRelay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/OperateRelay",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).OperateRelay(ctx, req.(*OperateRelayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_PurgeRelay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PurgeRelayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).PurgeRelay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/PurgeRelay",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).PurgeRelay(ctx, req.(*PurgeRelayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_UpdateRelayConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRelayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).UpdateRelayConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/UpdateRelayConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).UpdateRelayConfig(ctx, req.(*UpdateRelayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_QueryWorkerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryWorkerConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).QueryWorkerConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/QueryWorkerConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).QueryWorkerConfig(ctx, req.(*QueryWorkerConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Worker_MigrateRelay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MigrateRelayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WorkerServer).MigrateRelay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.Worker/MigrateRelay",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WorkerServer).MigrateRelay(ctx, req.(*MigrateRelayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Worker_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.Worker",
	HandlerType: (*WorkerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StartSubTask",
			Handler:    _Worker_StartSubTask_Handler,
		},
		{
			MethodName: "OperateSubTask",
			Handler:    _Worker_OperateSubTask_Handler,
		},
		{
			MethodName: "UpdateSubTask",
			Handler:    _Worker_UpdateSubTask_Handler,
		},
		{
			MethodName: "QueryStatus",
			Handler:    _Worker_QueryStatus_Handler,
		},
		{
			MethodName: "QueryError",
			Handler:    _Worker_QueryError_Handler,
		},
		{
			MethodName: "QueryTaskOperation",
			Handler:    _Worker_QueryTaskOperation_Handler,
		},
		{
			MethodName: "HandleSQLs",
			Handler:    _Worker_HandleSQLs_Handler,
		},
		{
			MethodName: "ExecuteDDL",
			Handler:    _Worker_ExecuteDDL_Handler,
		},
		{
			MethodName: "BreakDDLLock",
			Handler:    _Worker_BreakDDLLock_Handler,
		},
		{
			MethodName: "SwitchRelayMaster",
			Handler:    _Worker_SwitchRelayMaster_Handler,
		},
		{
			MethodName: "OperateRelay",
			Handler:    _Worker_OperateRelay_Handler,
		},
		{
			MethodName: "PurgeRelay",
			Handler:    _Worker_PurgeRelay_Handler,
		},
		{
			MethodName: "UpdateRelayConfig",
			Handler:    _Worker_UpdateRelayConfig_Handler,
		},
		{
			MethodName: "QueryWorkerConfig",
			Handler:    _Worker_QueryWorkerConfig_Handler,
		},
		{
			MethodName: "MigrateRelay",
			Handler:    _Worker_MigrateRelay_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "FetchDDLInfo",
			Handler:       _Worker_FetchDDLInfo_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "dmworker.proto",
}

func (m *StartSubTaskRequest) 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 *StartSubTaskRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	return i, nil
}

func (m *UpdateRelayRequest) 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 *UpdateRelayRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Content) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	return i, nil
}

func (m *MigrateRelayRequest) 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 *MigrateRelayRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.BinlogName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.BinlogName)))
		i += copy(dAtA[i:], m.BinlogName)
	}
	if m.BinlogPos != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.BinlogPos))
	}
	return i, nil
}

func (m *OperateSubTaskRequest) 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 *OperateSubTaskRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Op != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Op))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *OperateSubTaskResponse) 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 *OperateSubTaskResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Meta != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Meta.Size()))
		n1, err := m.Meta.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Op != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Op))
	}
	if m.LogID != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.LogID))
	}
	return i, nil
}

func (m *QueryTaskOperationRequest) 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 *QueryTaskOperationRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.LogID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.LogID))
	}
	return i, nil
}

func (m *QueryTaskOperationResponse) 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 *QueryTaskOperationResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Meta != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Meta.Size()))
		n2, err := m.Meta.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Log != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Log.Size()))
		n3, err := m.Log.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

func (m *UpdateSubTaskRequest) 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 *UpdateSubTaskRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	return i, nil
}

func (m *QueryStatusRequest) 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 *QueryStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *QueryErrorRequest) 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 *QueryErrorRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

func (m *HandleSubTaskSQLsRequest) 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 *HandleSubTaskSQLsRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Op != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Op))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.BinlogPos) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.BinlogPos)))
		i += copy(dAtA[i:], m.BinlogPos)
	}
	if len(m.SqlPattern) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.SqlPattern)))
		i += copy(dAtA[i:], m.SqlPattern)
	}
	return i, nil
}

func (m *CommonWorkerResponse) 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 *CommonWorkerResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Result {
		dAtA[i] = 0x8
		i++
		if m.Result {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Worker) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Worker)))
		i += copy(dAtA[i:], m.Worker)
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *QueryStatusResponse) 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 *QueryStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Result {
		dAtA[i] = 0x8
		i++
		if m.Result {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Worker) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Worker)))
		i += copy(dAtA[i:], m.Worker)
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.SubTaskStatus) > 0 {
		for _, msg := range m.SubTaskStatus {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.RelayStatus != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.RelayStatus.Size()))
		n4, err := m.RelayStatus.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if len(m.SourceID) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.SourceID)))
		i += copy(dAtA[i:], m.SourceID)
	}
	return i, nil
}

func (m *QueryErrorResponse) 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 *QueryErrorResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Result {
		dAtA[i] = 0x8
		i++
		if m.Result {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Worker) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Worker)))
		i += copy(dAtA[i:], m.Worker)
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.SubTaskError) > 0 {
		for _, msg := range m.SubTaskError {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.RelayError != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.RelayError.Size()))
		n5, err := m.RelayError.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}

func (m *CheckStatus) 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 *CheckStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Passed {
		dAtA[i] = 0x8
		i++
		if m.Passed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Total != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Total))
	}
	if m.Successful != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Successful))
	}
	if m.Failed != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Failed))
	}
	if m.Warning != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Warning))
	}
	if len(m.Detail) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Detail)))
		i += copy(dAtA[i:], m.Detail)
	}
	return i, nil
}

func (m *DumpStatus) 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 *DumpStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *LoadStatus) 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 *LoadStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.FinishedBytes != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.FinishedBytes))
	}
	if m.TotalBytes != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.TotalBytes))
	}
	if len(m.Progress) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Progress)))
		i += copy(dAtA[i:], m.Progress)
	}
	if len(m.MetaBinlog) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.MetaBinlog)))
		i += copy(dAtA[i:], m.MetaBinlog)
	}
	return i, nil
}

func (m *ShardingGroup) 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 *ShardingGroup) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Target) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Target)))
		i += copy(dAtA[i:], m.Target)
	}
	if len(m.DDLs) > 0 {
		for _, s := range m.DDLs {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.FirstPos) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.FirstPos)))
		i += copy(dAtA[i:], m.FirstPos)
	}
	if len(m.Synced) > 0 {
		for _, s := range m.Synced {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Unsynced) > 0 {
		for _, s := range m.Unsynced {
			dAtA[i] = 0x2a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *SyncStatus) 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 *SyncStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TotalEvents != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.TotalEvents))
	}
	if m.TotalTps != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.TotalTps))
	}
	if m.RecentTps != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.RecentTps))
	}
	if len(m.MasterBinlog) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.MasterBinlog)))
		i += copy(dAtA[i:], m.MasterBinlog)
	}
	if len(m.MasterBinlogGtid) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.MasterBinlogGtid)))
		i += copy(dAtA[i:], m.MasterBinlogGtid)
	}
	if len(m.SyncerBinlog) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.SyncerBinlog)))
		i += copy(dAtA[i:], m.SyncerBinlog)
	}
	if len(m.SyncerBinlogGtid) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.SyncerBinlogGtid)))
		i += copy(dAtA[i:], m.SyncerBinlogGtid)
	}
	if len(m.BlockingDDLs) > 0 {
		for _, s := range m.BlockingDDLs {
			dAtA[i] = 0x42
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.UnresolvedGroups) > 0 {
		for _, msg := range m.UnresolvedGroups {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Synced {
		dAtA[i] = 0x50
		i++
		if m.Synced {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *RelayStatus) 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 *RelayStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.MasterBinlog) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.MasterBinlog)))
		i += copy(dAtA[i:], m.MasterBinlog)
	}
	if len(m.MasterBinlogGtid) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.MasterBinlogGtid)))
		i += copy(dAtA[i:], m.MasterBinlogGtid)
	}
	if len(m.RelaySubDir) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.RelaySubDir)))
		i += copy(dAtA[i:], m.RelaySubDir)
	}
	if len(m.RelayBinlog) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.RelayBinlog)))
		i += copy(dAtA[i:], m.RelayBinlog)
	}
	if len(m.RelayBinlogGtid) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.RelayBinlogGtid)))
		i += copy(dAtA[i:], m.RelayBinlogGtid)
	}
	if m.RelayCatchUpMaster {
		dAtA[i] = 0x30
		i++
		if m.RelayCatchUpMaster {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Stage != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Stage))
	}
	if m.Result != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Result.Size()))
		n6, err := m.Result.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}

func (m *SubTaskStatus) 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 *SubTaskStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Stage != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Stage))
	}
	if m.Unit != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Unit))
	}
	if m.Result != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Result.Size()))
		n7, err := m.Result.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if len(m.UnresolvedDDLLockID) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.UnresolvedDDLLockID)))
		i += copy(dAtA[i:], m.UnresolvedDDLLockID)
	}
	if m.Status != nil {
		nn8, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn8
	}
	return i, nil
}

func (m *SubTaskStatus_Msg) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x32
	i++
	i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
	i += copy(dAtA[i:], m.Msg)
	return i, nil
}
func (m *SubTaskStatus_Check) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Check != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Check.Size()))
		n9, err := m.Check.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	return i, nil
}
func (m *SubTaskStatus_Dump) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Dump != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Dump.Size()))
		n10, err := m.Dump.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}
func (m *SubTaskStatus_Load) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Load != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Load.Size()))
		n11, err := m.Load.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *SubTaskStatus_Sync) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Sync != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Sync.Size()))
		n12, err := m.Sync.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}
func (m *SubTaskStatusList) 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 *SubTaskStatusList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Status) > 0 {
		for _, msg := range m.Status {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *CheckError) 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 *CheckError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *DumpError) 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 *DumpError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *LoadError) 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 *LoadError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *SyncSQLError) 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 *SyncSQLError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.FailedBinlogPosition) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.FailedBinlogPosition)))
		i += copy(dAtA[i:], m.FailedBinlogPosition)
	}
	if len(m.ErrorSQL) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.ErrorSQL)))
		i += copy(dAtA[i:], m.ErrorSQL)
	}
	return i, nil
}

func (m *SyncError) 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 *SyncError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Errors) > 0 {
		for _, msg := range m.Errors {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *RelayError) 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 *RelayError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *SubTaskError) 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 *SubTaskError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Stage != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Stage))
	}
	if m.Unit != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Unit))
	}
	if m.Error != nil {
		nn13, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn13
	}
	return i, nil
}

func (m *SubTaskError_Msg) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x22
	i++
	i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
	i += copy(dAtA[i:], m.Msg)
	return i, nil
}
func (m *SubTaskError_Check) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Check != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Check.Size()))
		n14, err := m.Check.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	return i, nil
}
func (m *SubTaskError_Dump) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Dump != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Dump.Size()))
		n15, err := m.Dump.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}
func (m *SubTaskError_Load) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Load != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Load.Size()))
		n16, err := m.Load.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}
func (m *SubTaskError_Sync) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Sync != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Sync.Size()))
		n17, err := m.Sync.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	return i, nil
}
func (m *SubTaskErrorList) 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 *SubTaskErrorList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Error) > 0 {
		for _, msg := range m.Error {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *ProcessResult) 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 *ProcessResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.IsCanceled {
		dAtA[i] = 0x8
		i++
		if m.IsCanceled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Errors) > 0 {
		for _, msg := range m.Errors {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDmworker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Detail) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Detail)))
		i += copy(dAtA[i:], m.Detail)
	}
	return i, nil
}

func (m *ProcessError) 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 *ProcessError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Type))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *DDLInfo) 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 *DDLInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	if len(m.Schema) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Schema)))
		i += copy(dAtA[i:], m.Schema)
	}
	if len(m.Table) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Table)))
		i += copy(dAtA[i:], m.Table)
	}
	if len(m.DDLs) > 0 {
		for _, s := range m.DDLs {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *DDLLockInfo) 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 *DDLLockInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	if len(m.ID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.ID)))
		i += copy(dAtA[i:], m.ID)
	}
	return i, nil
}

func (m *ExecDDLRequest) 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 *ExecDDLRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	if len(m.LockID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.LockID)))
		i += copy(dAtA[i:], m.LockID)
	}
	if m.Exec {
		dAtA[i] = 0x18
		i++
		if m.Exec {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.TraceGID) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.TraceGID)))
		i += copy(dAtA[i:], m.TraceGID)
	}
	return i, nil
}

func (m *BreakDDLLockRequest) 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 *BreakDDLLockRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	if len(m.RemoveLockID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.RemoveLockID)))
		i += copy(dAtA[i:], m.RemoveLockID)
	}
	if m.ExecDDL {
		dAtA[i] = 0x18
		i++
		if m.ExecDDL {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.SkipDDL {
		dAtA[i] = 0x20
		i++
		if m.SkipDDL {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *SwitchRelayMasterRequest) 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 *SwitchRelayMasterRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *OperateRelayRequest) 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 *OperateRelayRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Op != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Op))
	}
	return i, nil
}

func (m *OperateRelayResponse) 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 *OperateRelayResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Op != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Op))
	}
	if m.Result {
		dAtA[i] = 0x10
		i++
		if m.Result {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Worker) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Worker)))
		i += copy(dAtA[i:], m.Worker)
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	return i, nil
}

func (m *PurgeRelayRequest) 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 *PurgeRelayRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Inactive {
		dAtA[i] = 0x8
		i++
		if m.Inactive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Time != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Time))
	}
	if len(m.Filename) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Filename)))
		i += copy(dAtA[i:], m.Filename)
	}
	if len(m.SubDir) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.SubDir)))
		i += copy(dAtA[i:], m.SubDir)
	}
	return i, nil
}

func (m *QueryWorkerConfigRequest) 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 *QueryWorkerConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *QueryWorkerConfigResponse) 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 *QueryWorkerConfigResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Result {
		dAtA[i] = 0x8
		i++
		if m.Result {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Worker) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Worker)))
		i += copy(dAtA[i:], m.Worker)
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.SourceID) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.SourceID)))
		i += copy(dAtA[i:], m.SourceID)
	}
	if len(m.Content) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	return i, nil
}

func (m *TaskMeta) 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 *TaskMeta) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Op != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Op))
	}
	if m.Stage != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Stage))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Task) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	return i, nil
}

func (m *TaskLog) 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 *TaskLog) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Id))
	}
	if m.Task != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Task.Size()))
		n18, err := m.Task.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.Ts != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(m.Ts))
	}
	if m.Success {
		dAtA[i] = 0x20
		i++
		if m.Success {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDmworker(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	return i, nil
}

func encodeVarintDmworker(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 *StartSubTaskRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *UpdateRelayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *MigrateRelayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BinlogName)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.BinlogPos != 0 {
		n += 1 + sovDmworker(uint64(m.BinlogPos))
	}
	return n
}

func (m *OperateSubTaskRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovDmworker(uint64(m.Op))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *OperateSubTaskResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Meta != nil {
		l = m.Meta.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Op != 0 {
		n += 1 + sovDmworker(uint64(m.Op))
	}
	if m.LogID != 0 {
		n += 1 + sovDmworker(uint64(m.LogID))
	}
	return n
}

func (m *QueryTaskOperationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.LogID != 0 {
		n += 1 + sovDmworker(uint64(m.LogID))
	}
	return n
}

func (m *QueryTaskOperationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Meta != nil {
		l = m.Meta.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Log != nil {
		l = m.Log.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *UpdateSubTaskRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *QueryStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *QueryErrorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *HandleSubTaskSQLsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Op != 0 {
		n += 1 + sovDmworker(uint64(m.Op))
	}
	if len(m.Args) > 0 {
		for _, s := range m.Args {
			l = len(s)
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	l = len(m.BinlogPos)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.SqlPattern)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *CommonWorkerResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result {
		n += 2
	}
	l = len(m.Worker)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *QueryStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result {
		n += 2
	}
	l = len(m.Worker)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if len(m.SubTaskStatus) > 0 {
		for _, e := range m.SubTaskStatus {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	if m.RelayStatus != nil {
		l = m.RelayStatus.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.SourceID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *QueryErrorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result {
		n += 2
	}
	l = len(m.Worker)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if len(m.SubTaskError) > 0 {
		for _, e := range m.SubTaskError {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	if m.RelayError != nil {
		l = m.RelayError.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *CheckStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Passed {
		n += 2
	}
	if m.Total != 0 {
		n += 1 + sovDmworker(uint64(m.Total))
	}
	if m.Successful != 0 {
		n += 1 + sovDmworker(uint64(m.Successful))
	}
	if m.Failed != 0 {
		n += 1 + sovDmworker(uint64(m.Failed))
	}
	if m.Warning != 0 {
		n += 1 + sovDmworker(uint64(m.Warning))
	}
	l = len(m.Detail)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *DumpStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *LoadStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FinishedBytes != 0 {
		n += 1 + sovDmworker(uint64(m.FinishedBytes))
	}
	if m.TotalBytes != 0 {
		n += 1 + sovDmworker(uint64(m.TotalBytes))
	}
	l = len(m.Progress)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.MetaBinlog)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *ShardingGroup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Target)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if len(m.DDLs) > 0 {
		for _, s := range m.DDLs {
			l = len(s)
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	l = len(m.FirstPos)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if len(m.Synced) > 0 {
		for _, s := range m.Synced {
			l = len(s)
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	if len(m.Unsynced) > 0 {
		for _, s := range m.Unsynced {
			l = len(s)
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	return n
}

func (m *SyncStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TotalEvents != 0 {
		n += 1 + sovDmworker(uint64(m.TotalEvents))
	}
	if m.TotalTps != 0 {
		n += 1 + sovDmworker(uint64(m.TotalTps))
	}
	if m.RecentTps != 0 {
		n += 1 + sovDmworker(uint64(m.RecentTps))
	}
	l = len(m.MasterBinlog)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.MasterBinlogGtid)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.SyncerBinlog)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.SyncerBinlogGtid)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if len(m.BlockingDDLs) > 0 {
		for _, s := range m.BlockingDDLs {
			l = len(s)
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	if len(m.UnresolvedGroups) > 0 {
		for _, e := range m.UnresolvedGroups {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	if m.Synced {
		n += 2
	}
	return n
}

func (m *RelayStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MasterBinlog)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.MasterBinlogGtid)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.RelaySubDir)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.RelayBinlog)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.RelayBinlogGtid)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.RelayCatchUpMaster {
		n += 2
	}
	if m.Stage != 0 {
		n += 1 + sovDmworker(uint64(m.Stage))
	}
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *SubTaskStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Stage != 0 {
		n += 1 + sovDmworker(uint64(m.Stage))
	}
	if m.Unit != 0 {
		n += 1 + sovDmworker(uint64(m.Unit))
	}
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.UnresolvedDDLLockID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Status != nil {
		n += m.Status.Size()
	}
	return n
}

func (m *SubTaskStatus_Msg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	n += 1 + l + sovDmworker(uint64(l))
	return n
}
func (m *SubTaskStatus_Check) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Check != nil {
		l = m.Check.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskStatus_Dump) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Dump != nil {
		l = m.Dump.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskStatus_Load) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Load != nil {
		l = m.Load.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskStatus_Sync) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sync != nil {
		l = m.Sync.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskStatusList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Status) > 0 {
		for _, e := range m.Status {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	return n
}

func (m *CheckError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *DumpError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *LoadError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *SyncSQLError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.FailedBinlogPosition)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.ErrorSQL)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *SyncError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Errors) > 0 {
		for _, e := range m.Errors {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	return n
}

func (m *RelayError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *SubTaskError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Stage != 0 {
		n += 1 + sovDmworker(uint64(m.Stage))
	}
	if m.Unit != 0 {
		n += 1 + sovDmworker(uint64(m.Unit))
	}
	if m.Error != nil {
		n += m.Error.Size()
	}
	return n
}

func (m *SubTaskError_Msg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Msg)
	n += 1 + l + sovDmworker(uint64(l))
	return n
}
func (m *SubTaskError_Check) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Check != nil {
		l = m.Check.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskError_Dump) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Dump != nil {
		l = m.Dump.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskError_Load) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Load != nil {
		l = m.Load.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskError_Sync) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sync != nil {
		l = m.Sync.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}
func (m *SubTaskErrorList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Error) > 0 {
		for _, e := range m.Error {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	return n
}

func (m *ProcessResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsCanceled {
		n += 2
	}
	if len(m.Errors) > 0 {
		for _, e := range m.Errors {
			l = e.Size()
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	l = len(m.Detail)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *ProcessError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovDmworker(uint64(m.Type))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *DDLInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Schema)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Table)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if len(m.DDLs) > 0 {
		for _, s := range m.DDLs {
			l = len(s)
			n += 1 + l + sovDmworker(uint64(l))
		}
	}
	return n
}

func (m *DDLLockInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *ExecDDLRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.LockID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Exec {
		n += 2
	}
	l = len(m.TraceGID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *BreakDDLLockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.RemoveLockID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.ExecDDL {
		n += 2
	}
	if m.SkipDDL {
		n += 2
	}
	return n
}

func (m *SwitchRelayMasterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *OperateRelayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovDmworker(uint64(m.Op))
	}
	return n
}

func (m *OperateRelayResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovDmworker(uint64(m.Op))
	}
	if m.Result {
		n += 2
	}
	l = len(m.Worker)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *PurgeRelayRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Inactive {
		n += 2
	}
	if m.Time != 0 {
		n += 1 + sovDmworker(uint64(m.Time))
	}
	l = len(m.Filename)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.SubDir)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *QueryWorkerConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryWorkerConfigResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result {
		n += 2
	}
	l = len(m.Worker)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.SourceID)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *TaskMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovDmworker(uint64(m.Op))
	}
	if m.Stage != 0 {
		n += 1 + sovDmworker(uint64(m.Stage))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func (m *TaskLog) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovDmworker(uint64(m.Id))
	}
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovDmworker(uint64(l))
	}
	if m.Ts != 0 {
		n += 1 + sovDmworker(uint64(m.Ts))
	}
	if m.Success {
		n += 2
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovDmworker(uint64(l))
	}
	return n
}

func sovDmworker(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozDmworker(x uint64) (n int) {
	return sovDmworker(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *StartSubTaskRequest) 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 ErrIntOverflowDmworker
			}
			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: StartSubTaskRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StartSubTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateRelayRequest) 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 ErrIntOverflowDmworker
			}
			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: UpdateRelayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateRelayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MigrateRelayRequest) 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 ErrIntOverflowDmworker
			}
			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: MigrateRelayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MigrateRelayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinlogName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BinlogName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinlogPos", wireType)
			}
			m.BinlogPos = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BinlogPos |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OperateSubTaskRequest) 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 ErrIntOverflowDmworker
			}
			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: OperateSubTaskRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OperateSubTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= TaskOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OperateSubTaskResponse) 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 ErrIntOverflowDmworker
			}
			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: OperateSubTaskResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OperateSubTaskResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Meta == nil {
				m.Meta = &CommonWorkerResponse{}
			}
			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= TaskOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
			}
			m.LogID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryTaskOperationRequest) 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 ErrIntOverflowDmworker
			}
			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: QueryTaskOperationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaskOperationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
			}
			m.LogID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryTaskOperationResponse) 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 ErrIntOverflowDmworker
			}
			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: QueryTaskOperationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTaskOperationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Meta == nil {
				m.Meta = &CommonWorkerResponse{}
			}
			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Log == nil {
				m.Log = &TaskLog{}
			}
			if err := m.Log.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateSubTaskRequest) 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 ErrIntOverflowDmworker
			}
			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: UpdateSubTaskRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateSubTaskRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryStatusRequest) 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 ErrIntOverflowDmworker
			}
			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: QueryStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryErrorRequest) 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 ErrIntOverflowDmworker
			}
			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: QueryErrorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryErrorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HandleSubTaskSQLsRequest) 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 ErrIntOverflowDmworker
			}
			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: HandleSubTaskSQLsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HandleSubTaskSQLsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= SQLOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinlogPos", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BinlogPos = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SqlPattern", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SqlPattern = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommonWorkerResponse) 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 ErrIntOverflowDmworker
			}
			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: CommonWorkerResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommonWorkerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Result = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryStatusResponse) 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 ErrIntOverflowDmworker
			}
			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: QueryStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Result = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubTaskStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubTaskStatus = append(m.SubTaskStatus, &SubTaskStatus{})
			if err := m.SubTaskStatus[len(m.SubTaskStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RelayStatus == nil {
				m.RelayStatus = &RelayStatus{}
			}
			if err := m.RelayStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryErrorResponse) 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 ErrIntOverflowDmworker
			}
			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: QueryErrorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryErrorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Result = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubTaskError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubTaskError = append(m.SubTaskError, &SubTaskError{})
			if err := m.SubTaskError[len(m.SubTaskError)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RelayError == nil {
				m.RelayError = &RelayError{}
			}
			if err := m.RelayError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CheckStatus) 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 ErrIntOverflowDmworker
			}
			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: CheckStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CheckStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Passed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Passed = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Successful", wireType)
			}
			m.Successful = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Successful |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
			}
			m.Failed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Failed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Warning", wireType)
			}
			m.Warning = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Warning |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Detail = append(m.Detail[:0], dAtA[iNdEx:postIndex]...)
			if m.Detail == nil {
				m.Detail = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DumpStatus) 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 ErrIntOverflowDmworker
			}
			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: DumpStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DumpStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LoadStatus) 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 ErrIntOverflowDmworker
			}
			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: LoadStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoadStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinishedBytes", wireType)
			}
			m.FinishedBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FinishedBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType)
			}
			m.TotalBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Progress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetaBinlog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetaBinlog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ShardingGroup) 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 ErrIntOverflowDmworker
			}
			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: ShardingGroup: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ShardingGroup: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Target = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DDLs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DDLs = append(m.DDLs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstPos", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FirstPos = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Synced", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Synced = append(m.Synced, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unsynced", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unsynced = append(m.Unsynced, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncStatus) 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 ErrIntOverflowDmworker
			}
			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: SyncStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalEvents", wireType)
			}
			m.TotalEvents = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalEvents |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalTps", wireType)
			}
			m.TotalTps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalTps |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecentTps", wireType)
			}
			m.RecentTps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecentTps |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterBinlog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MasterBinlog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterBinlogGtid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MasterBinlogGtid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncerBinlog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SyncerBinlog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncerBinlogGtid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SyncerBinlogGtid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockingDDLs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockingDDLs = append(m.BlockingDDLs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnresolvedGroups", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnresolvedGroups = append(m.UnresolvedGroups, &ShardingGroup{})
			if err := m.UnresolvedGroups[len(m.UnresolvedGroups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Synced", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Synced = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RelayStatus) 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 ErrIntOverflowDmworker
			}
			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: RelayStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelayStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterBinlog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MasterBinlog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterBinlogGtid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MasterBinlogGtid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelaySubDir", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelaySubDir = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayBinlog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelayBinlog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayBinlogGtid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RelayBinlogGtid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelayCatchUpMaster", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RelayCatchUpMaster = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType)
			}
			m.Stage = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stage |= Stage(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &ProcessResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubTaskStatus) 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 ErrIntOverflowDmworker
			}
			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: SubTaskStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubTaskStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType)
			}
			m.Stage = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stage |= Stage(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			m.Unit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Unit |= UnitType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &ProcessResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnresolvedDDLLockID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnresolvedDDLLockID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = &SubTaskStatus_Msg{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Check", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CheckStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Status = &SubTaskStatus_Check{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dump", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DumpStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Status = &SubTaskStatus_Dump{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &LoadStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Status = &SubTaskStatus_Load{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sync", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SyncStatus{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Status = &SubTaskStatus_Sync{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubTaskStatusList) 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 ErrIntOverflowDmworker
			}
			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: SubTaskStatusList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubTaskStatusList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = append(m.Status, &SubTaskStatus{})
			if err := m.Status[len(m.Status)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CheckError) 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 ErrIntOverflowDmworker
			}
			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: CheckError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CheckError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DumpError) 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 ErrIntOverflowDmworker
			}
			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: DumpError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DumpError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LoadError) 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 ErrIntOverflowDmworker
			}
			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: LoadError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoadError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncSQLError) 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 ErrIntOverflowDmworker
			}
			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: SyncSQLError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncSQLError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailedBinlogPosition", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FailedBinlogPosition = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorSQL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorSQL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SyncError) 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 ErrIntOverflowDmworker
			}
			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: SyncError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Errors = append(m.Errors, &SyncSQLError{})
			if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RelayError) 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 ErrIntOverflowDmworker
			}
			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: RelayError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RelayError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubTaskError) 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 ErrIntOverflowDmworker
			}
			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: SubTaskError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubTaskError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType)
			}
			m.Stage = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stage |= Stage(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			m.Unit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Unit |= UnitType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = &SubTaskError_Msg{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Check", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CheckError{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Error = &SubTaskError_Check{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dump", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DumpError{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Error = &SubTaskError_Dump{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &LoadError{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Error = &SubTaskError_Load{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sync", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SyncError{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Error = &SubTaskError_Sync{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubTaskErrorList) 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 ErrIntOverflowDmworker
			}
			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: SubTaskErrorList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubTaskErrorList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = append(m.Error, &SubTaskError{})
			if err := m.Error[len(m.Error)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessResult) 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 ErrIntOverflowDmworker
			}
			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: ProcessResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsCanceled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsCanceled = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Errors = append(m.Errors, &ProcessError{})
			if err := m.Errors[len(m.Errors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Detail = append(m.Detail[:0], dAtA[iNdEx:postIndex]...)
			if m.Detail == nil {
				m.Detail = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessError) 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 ErrIntOverflowDmworker
			}
			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: ProcessError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ErrorType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DDLInfo) 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 ErrIntOverflowDmworker
			}
			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: DDLInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DDLInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schema = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DDLs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DDLs = append(m.DDLs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DDLLockInfo) 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 ErrIntOverflowDmworker
			}
			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: DDLLockInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DDLLockInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecDDLRequest) 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 ErrIntOverflowDmworker
			}
			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: ExecDDLRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecDDLRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LockID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exec", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Exec = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceGID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TraceGID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BreakDDLLockRequest) 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 ErrIntOverflowDmworker
			}
			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: BreakDDLLockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BreakDDLLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveLockID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RemoveLockID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecDDL", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExecDDL = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipDDL", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipDDL = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SwitchRelayMasterRequest) 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 ErrIntOverflowDmworker
			}
			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: SwitchRelayMasterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SwitchRelayMasterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OperateRelayRequest) 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 ErrIntOverflowDmworker
			}
			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: OperateRelayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OperateRelayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= RelayOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OperateRelayResponse) 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 ErrIntOverflowDmworker
			}
			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: OperateRelayResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OperateRelayResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= RelayOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Result = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PurgeRelayRequest) 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 ErrIntOverflowDmworker
			}
			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: PurgeRelayRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PurgeRelayRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inactive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Inactive = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filename = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubDir", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubDir = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryWorkerConfigRequest) 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 ErrIntOverflowDmworker
			}
			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: QueryWorkerConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryWorkerConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryWorkerConfigResponse) 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 ErrIntOverflowDmworker
			}
			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: QueryWorkerConfigResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryWorkerConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Result = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaskMeta) 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 ErrIntOverflowDmworker
			}
			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: TaskMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= TaskOp(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stage", wireType)
			}
			m.Stage = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stage |= Stage(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Task = append(m.Task[:0], dAtA[iNdEx:postIndex]...)
			if m.Task == nil {
				m.Task = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaskLog) 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 ErrIntOverflowDmworker
			}
			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: TaskLog: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskLog: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &TaskMeta{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ts |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Success = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDmworker
				}
				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 ErrInvalidLengthDmworker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDmworker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDmworker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDmworker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDmworker(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, ErrIntOverflowDmworker
			}
			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, ErrIntOverflowDmworker
				}
				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, ErrIntOverflowDmworker
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthDmworker
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthDmworker
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowDmworker
					}
					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 := skipDmworker(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthDmworker
				}
			}
			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 (
	ErrInvalidLengthDmworker = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDmworker   = fmt.Errorf("proto: integer overflow")
)