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

/*
	Package whpb is a generated protocol buffer package.

	It is generated from these files:
		metapb.proto

	It has these top-level messages:
		Label
		Worker
		Position
		JobStatus
		Job
		MysqlDumpJob
		MysqlBinlogJob
		MysqlSyncJob
		DBAccount
		RouteRule
		SchemaInfo
		Schema
		SchemaDetail
		Topic
		Partition
		Partitions
		TopicPartitionBitmap
		Fence
		DMLData
		RowData
		Column
		Drip
*/
package whpb

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import io "io"

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

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

// mysql_binlog and mysql_dump is for Portal.
// mysql_sync is for stargate.
type SourceType int32

const (
	SourceType_mysql_binlog SourceType = 0
	SourceType_mysql_dump   SourceType = 1
)

var SourceType_name = map[int32]string{
	0: "mysql_binlog",
	1: "mysql_dump",
}
var SourceType_value = map[string]int32{
	"mysql_binlog": 0,
	"mysql_dump":   1,
}

func (x SourceType) Enum() *SourceType {
	p := new(SourceType)
	*p = x
	return p
}
func (x SourceType) String() string {
	return proto.EnumName(SourceType_name, int32(x))
}
func (x *SourceType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SourceType_value, data, "SourceType")
	if err != nil {
		return err
	}
	*x = SourceType(value)
	return nil
}
func (SourceType) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{0} }

type WorkerType int32

const (
	WorkerType_Portal   WorkerType = 0
	WorkerType_Stargate WorkerType = 1
)

var WorkerType_name = map[int32]string{
	0: "Portal",
	1: "Stargate",
}
var WorkerType_value = map[string]int32{
	"Portal":   0,
	"Stargate": 1,
}

func (x WorkerType) Enum() *WorkerType {
	p := new(WorkerType)
	*p = x
	return p
}
func (x WorkerType) String() string {
	return proto.EnumName(WorkerType_name, int32(x))
}
func (x *WorkerType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(WorkerType_value, data, "WorkerType")
	if err != nil {
		return err
	}
	*x = WorkerType(value)
	return nil
}
func (WorkerType) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{1} }

type OPType int32

const (
	OPType_DDL OPType = 0
	OPType_DML OPType = 1
	OPType_END OPType = 2
)

var OPType_name = map[int32]string{
	0: "DDL",
	1: "DML",
	2: "END",
}
var OPType_value = map[string]int32{
	"DDL": 0,
	"DML": 1,
	"END": 2,
}

func (x OPType) Enum() *OPType {
	p := new(OPType)
	*p = x
	return p
}
func (x OPType) String() string {
	return proto.EnumName(OPType_name, int32(x))
}
func (x *OPType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(OPType_value, data, "OPType")
	if err != nil {
		return err
	}
	*x = OPType(value)
	return nil
}
func (OPType) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{2} }

type EventType int32

const (
	EventType_Insert EventType = 0
	EventType_Update EventType = 1
	EventType_Delete EventType = 2
)

var EventType_name = map[int32]string{
	0: "Insert",
	1: "Update",
	2: "Delete",
}
var EventType_value = map[string]int32{
	"Insert": 0,
	"Update": 1,
	"Delete": 2,
}

func (x EventType) Enum() *EventType {
	p := new(EventType)
	*p = x
	return p
}
func (x EventType) String() string {
	return proto.EnumName(EventType_name, int32(x))
}
func (x *EventType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(EventType_value, data, "EventType")
	if err != nil {
		return err
	}
	*x = EventType(value)
	return nil
}
func (EventType) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{3} }

type JobState int32

const (
	JobState_Normal   JobState = 0
	JobState_Abnormal JobState = 1
	JobState_Paused   JobState = 2
)

var JobState_name = map[int32]string{
	0: "Normal",
	1: "Abnormal",
	2: "Paused",
}
var JobState_value = map[string]int32{
	"Normal":   0,
	"Abnormal": 1,
	"Paused":   2,
}

func (x JobState) Enum() *JobState {
	p := new(JobState)
	*p = x
	return p
}
func (x JobState) String() string {
	return proto.EnumName(JobState_name, int32(x))
}
func (x *JobState) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(JobState_value, data, "JobState")
	if err != nil {
		return err
	}
	*x = JobState(value)
	return nil
}
func (JobState) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{4} }

type JobStage int32

const (
	JobStage_New          JobStage = 0
	JobStage_Initializing JobStage = 1
	JobStage_Running      JobStage = 2
	JobStage_Resolved     JobStage = 3
	JobStage_Deleting     JobStage = 4
	JobStage_Deleted      JobStage = 5
)

var JobStage_name = map[int32]string{
	0: "New",
	1: "Initializing",
	2: "Running",
	3: "Resolved",
	4: "Deleting",
	5: "Deleted",
}
var JobStage_value = map[string]int32{
	"New":          0,
	"Initializing": 1,
	"Running":      2,
	"Resolved":     3,
	"Deleting":     4,
	"Deleted":      5,
}

func (x JobStage) Enum() *JobStage {
	p := new(JobStage)
	*p = x
	return p
}
func (x JobStage) String() string {
	return proto.EnumName(JobStage_name, int32(x))
}
func (x *JobStage) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(JobStage_value, data, "JobStage")
	if err != nil {
		return err
	}
	*x = JobStage(value)
	return nil
}
func (JobStage) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{5} }

type Label struct {
	Vals             []string `protobuf:"bytes,1,rep,name=vals" json:"vals"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *Label) Reset()                    { *m = Label{} }
func (m *Label) String() string            { return proto.CompactTextString(m) }
func (*Label) ProtoMessage()               {}
func (*Label) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{0} }

func (m *Label) GetVals() []string {
	if m != nil {
		return m.Vals
	}
	return nil
}

type Worker struct {
	Id   uint64     `protobuf:"varint,1,opt,name=id" json:"id"`
	Type WorkerType `protobuf:"varint,2,opt,name=type,enum=whpb.WorkerType" json:"type"`
	// labels of worker like group, support protocol etc.
	Labels map[string]*Label `protobuf:"bytes,3,rep,name=labels" json:"labels" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// some annotations
	Annotations      map[string]string `protobuf:"bytes,4,rep,name=annotations" json:"annotations" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	CreateTime       int64             `protobuf:"varint,5,opt,name=create_time,json=createTime" json:"create_time"`
	LastTime         int64             `protobuf:"varint,6,opt,name=last_time,json=lastTime" json:"last_time"`
	XXX_unrecognized []byte            `json:"-"`
}

func (m *Worker) Reset()                    { *m = Worker{} }
func (m *Worker) String() string            { return proto.CompactTextString(m) }
func (*Worker) ProtoMessage()               {}
func (*Worker) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{1} }

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

func (m *Worker) GetType() WorkerType {
	if m != nil {
		return m.Type
	}
	return WorkerType_Portal
}

func (m *Worker) GetLabels() map[string]*Label {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *Worker) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

func (m *Worker) GetCreateTime() int64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

func (m *Worker) GetLastTime() int64 {
	if m != nil {
		return m.LastTime
	}
	return 0
}

// job's progress position information.
type Position struct {
	MysqlBinlogFile  string `protobuf:"bytes,1,opt,name=mysql_binlog_file,json=mysqlBinlogFile" json:"mysql_binlog_file"`
	MysqlBinlogPos   uint64 `protobuf:"varint,2,opt,name=mysql_binlog_pos,json=mysqlBinlogPos" json:"mysql_binlog_pos"`
	MysqlBinlogGtid  string `protobuf:"bytes,3,opt,name=mysql_binlog_gtid,json=mysqlBinlogGtid" json:"mysql_binlog_gtid"`
	MongoTs          int64  `protobuf:"varint,4,opt,name=mongo_ts,json=mongoTs" json:"mongo_ts"`
	KafkaOffset      int64  `protobuf:"varint,5,opt,name=kafka_offset,json=kafkaOffset" json:"kafka_offset"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Position) Reset()                    { *m = Position{} }
func (m *Position) String() string            { return proto.CompactTextString(m) }
func (*Position) ProtoMessage()               {}
func (*Position) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{2} }

func (m *Position) GetMysqlBinlogFile() string {
	if m != nil {
		return m.MysqlBinlogFile
	}
	return ""
}

func (m *Position) GetMysqlBinlogPos() uint64 {
	if m != nil {
		return m.MysqlBinlogPos
	}
	return 0
}

func (m *Position) GetMysqlBinlogGtid() string {
	if m != nil {
		return m.MysqlBinlogGtid
	}
	return ""
}

func (m *Position) GetMongoTs() int64 {
	if m != nil {
		return m.MongoTs
	}
	return 0
}

func (m *Position) GetKafkaOffset() int64 {
	if m != nil {
		return m.KafkaOffset
	}
	return 0
}

type JobStatus struct {
	Id        uint64   `protobuf:"varint,1,opt,name=id" json:"id"`
	Stage     JobStage `protobuf:"varint,2,opt,name=stage,enum=whpb.JobStage" json:"stage"`
	State     JobState `protobuf:"varint,3,opt,name=state,enum=whpb.JobState" json:"state"`
	Type      string   `protobuf:"bytes,4,opt,name=type" json:"type"`
	Replicate int32    `protobuf:"varint,5,opt,name=replicate" json:"replicate"`
	// job's total quantity
	Total uint64 `protobuf:"varint,6,opt,name=total" json:"total"`
	// job's progress expressed by percent
	Percent uint64 `protobuf:"varint,7,opt,name=percent" json:"percent"`
	// job's current progress.
	Pos *Position `protobuf:"bytes,8,opt,name=pos" json:"pos"`
	// job's qps
	Qps uint64 `protobuf:"varint,9,opt,name=qps" json:"qps"`
	// The number of messages that not consumed
	DelayMessageCount *int64 `protobuf:"varint,10,opt,name=delay_message_count,json=delayMessageCount" json:"delay_message_count"`
	// error message
	Message          string `protobuf:"bytes,11,opt,name=message" json:"message"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *JobStatus) Reset()                    { *m = JobStatus{} }
func (m *JobStatus) String() string            { return proto.CompactTextString(m) }
func (*JobStatus) ProtoMessage()               {}
func (*JobStatus) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{3} }

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

func (m *JobStatus) GetStage() JobStage {
	if m != nil {
		return m.Stage
	}
	return JobStage_New
}

func (m *JobStatus) GetState() JobState {
	if m != nil {
		return m.State
	}
	return JobState_Normal
}

func (m *JobStatus) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *JobStatus) GetReplicate() int32 {
	if m != nil {
		return m.Replicate
	}
	return 0
}

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

func (m *JobStatus) GetPercent() uint64 {
	if m != nil {
		return m.Percent
	}
	return 0
}

func (m *JobStatus) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *JobStatus) GetQps() uint64 {
	if m != nil {
		return m.Qps
	}
	return 0
}

func (m *JobStatus) GetDelayMessageCount() int64 {
	if m != nil && m.DelayMessageCount != nil {
		return *m.DelayMessageCount
	}
	return 0
}

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

type Job struct {
	Id     uint64     `protobuf:"varint,1,opt,name=id" json:"id"`
	Status *JobStatus `protobuf:"bytes,2,opt,name=status" json:"status"`
	Type   WorkerType `protobuf:"varint,3,opt,name=type,enum=whpb.WorkerType" json:"type"`
	Source SourceType `protobuf:"varint,4,opt,name=source,enum=whpb.SourceType" json:"source"`
	// detail information of job, contains source/target db and mq topic informations.
	Info []byte `protobuf:"bytes,5,opt,name=info" json:"info"`
	// labels of job, used to schedule job and worker.
	Labels map[string]*Label `protobuf:"bytes,6,rep,name=labels" json:"labels" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// some annotations, cluster etcd root path stored in `clusterRootPath`.
	Annotations map[string]string `protobuf:"bytes,7,rep,name=annotations" json:"annotations" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// dependencies of job, scheduled util all those jobs are finished.
	Dependencies     []uint64 `protobuf:"varint,8,rep,name=dependencies" json:"dependencies"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *Job) Reset()                    { *m = Job{} }
func (m *Job) String() string            { return proto.CompactTextString(m) }
func (*Job) ProtoMessage()               {}
func (*Job) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{4} }

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

func (m *Job) GetStatus() *JobStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *Job) GetType() WorkerType {
	if m != nil {
		return m.Type
	}
	return WorkerType_Portal
}

func (m *Job) GetSource() SourceType {
	if m != nil {
		return m.Source
	}
	return SourceType_mysql_binlog
}

func (m *Job) GetInfo() []byte {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *Job) GetLabels() map[string]*Label {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *Job) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

func (m *Job) GetDependencies() []uint64 {
	if m != nil {
		return m.Dependencies
	}
	return nil
}

type MysqlDumpJob struct {
	// datasource information
	Source DBAccount `protobuf:"bytes,1,opt,name=source" json:"source"`
	// optional. databases and tables to dump
	Schemas []*Schema `protobuf:"bytes,2,rep,name=schemas" json:"schemas"`
	// for later scale use
	PartitionNum     int32  `protobuf:"varint,3,opt,name=partition_num,json=partitionNum" json:"partition_num"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *MysqlDumpJob) Reset()                    { *m = MysqlDumpJob{} }
func (m *MysqlDumpJob) String() string            { return proto.CompactTextString(m) }
func (*MysqlDumpJob) ProtoMessage()               {}
func (*MysqlDumpJob) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{5} }

func (m *MysqlDumpJob) GetSource() DBAccount {
	if m != nil {
		return m.Source
	}
	return DBAccount{}
}

func (m *MysqlDumpJob) GetSchemas() []*Schema {
	if m != nil {
		return m.Schemas
	}
	return nil
}

func (m *MysqlDumpJob) GetPartitionNum() int32 {
	if m != nil {
		return m.PartitionNum
	}
	return 0
}

type MysqlBinlogJob struct {
	// datasource information
	Source DBAccount `protobuf:"bytes,1,opt,name=source" json:"source"`
	// optional. databases and tables to fetch binlog.
	Schemas []*Schema `protobuf:"bytes,2,rep,name=schemas" json:"schemas"`
	// for later scale use
	PartitionNum     int32  `protobuf:"varint,3,opt,name=partition_num,json=partitionNum" json:"partition_num"`
	ServerId         int32  `protobuf:"varint,4,opt,name=server_id,json=serverId" json:"server_id"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *MysqlBinlogJob) Reset()                    { *m = MysqlBinlogJob{} }
func (m *MysqlBinlogJob) String() string            { return proto.CompactTextString(m) }
func (*MysqlBinlogJob) ProtoMessage()               {}
func (*MysqlBinlogJob) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{6} }

func (m *MysqlBinlogJob) GetSource() DBAccount {
	if m != nil {
		return m.Source
	}
	return DBAccount{}
}

func (m *MysqlBinlogJob) GetSchemas() []*Schema {
	if m != nil {
		return m.Schemas
	}
	return nil
}

func (m *MysqlBinlogJob) GetPartitionNum() int32 {
	if m != nil {
		return m.PartitionNum
	}
	return 0
}

func (m *MysqlBinlogJob) GetServerId() int32 {
	if m != nil {
		return m.ServerId
	}
	return 0
}

type MysqlSyncJob struct {
	// datasource information.
	Source SchemaInfo `protobuf:"bytes,1,opt,name=source" json:"source"`
	// target database information.
	Target DBAccount `protobuf:"bytes,2,opt,name=target" json:"target"`
	// optional. sharding rules.
	Rules            []*RouteRule `protobuf:"bytes,3,rep,name=rules" json:"rules"`
	XXX_unrecognized []byte       `json:"-"`
}

func (m *MysqlSyncJob) Reset()                    { *m = MysqlSyncJob{} }
func (m *MysqlSyncJob) String() string            { return proto.CompactTextString(m) }
func (*MysqlSyncJob) ProtoMessage()               {}
func (*MysqlSyncJob) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{7} }

func (m *MysqlSyncJob) GetSource() SchemaInfo {
	if m != nil {
		return m.Source
	}
	return SchemaInfo{}
}

func (m *MysqlSyncJob) GetTarget() DBAccount {
	if m != nil {
		return m.Target
	}
	return DBAccount{}
}

func (m *MysqlSyncJob) GetRules() []*RouteRule {
	if m != nil {
		return m.Rules
	}
	return nil
}

type DBAccount struct {
	Host             string `protobuf:"bytes,1,opt,name=host" json:"host"`
	Port             int32  `protobuf:"varint,2,opt,name=port" json:"port"`
	Username         string `protobuf:"bytes,3,opt,name=username" json:"username"`
	Password         string `protobuf:"bytes,4,opt,name=password" json:"password"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *DBAccount) Reset()                    { *m = DBAccount{} }
func (m *DBAccount) String() string            { return proto.CompactTextString(m) }
func (*DBAccount) ProtoMessage()               {}
func (*DBAccount) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{8} }

func (m *DBAccount) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *DBAccount) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *DBAccount) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *DBAccount) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

// for pattern, we use simple wildcard:
// 1. asterisk character (*, also called "star") matches zero or more characters,
//    for example, doc* matches doc and document but not dodo;
//    asterisk character must be in the end of wildcard word,
//    and there is only one asterisk in one wildcard word
// 2. the question mark ? matches exactly one character
type RouteRule struct {
	SchemaPattern    string  `protobuf:"bytes,1,opt,name=schema_pattern,json=schemaPattern" json:"schema_pattern"`
	TablePattern     *string `protobuf:"bytes,2,opt,name=table_pattern,json=tablePattern" json:"table_pattern"`
	TargetSchema     string  `protobuf:"bytes,3,opt,name=target_schema,json=targetSchema" json:"target_schema"`
	TargetTable      *string `protobuf:"bytes,4,opt,name=target_table,json=targetTable" json:"target_table"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *RouteRule) Reset()                    { *m = RouteRule{} }
func (m *RouteRule) String() string            { return proto.CompactTextString(m) }
func (*RouteRule) ProtoMessage()               {}
func (*RouteRule) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{9} }

func (m *RouteRule) GetSchemaPattern() string {
	if m != nil {
		return m.SchemaPattern
	}
	return ""
}

func (m *RouteRule) GetTablePattern() string {
	if m != nil && m.TablePattern != nil {
		return *m.TablePattern
	}
	return ""
}

func (m *RouteRule) GetTargetSchema() string {
	if m != nil {
		return m.TargetSchema
	}
	return ""
}

func (m *RouteRule) GetTargetTable() string {
	if m != nil && m.TargetTable != nil {
		return *m.TargetTable
	}
	return ""
}

type SchemaInfo struct {
	Host             string    `protobuf:"bytes,1,opt,name=host" json:"host"`
	Port             int32     `protobuf:"varint,2,opt,name=port" json:"port"`
	Schemas          []*Schema `protobuf:"bytes,3,rep,name=schemas" json:"schemas"`
	XXX_unrecognized []byte    `json:"-"`
}

func (m *SchemaInfo) Reset()                    { *m = SchemaInfo{} }
func (m *SchemaInfo) String() string            { return proto.CompactTextString(m) }
func (*SchemaInfo) ProtoMessage()               {}
func (*SchemaInfo) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{10} }

func (m *SchemaInfo) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *SchemaInfo) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *SchemaInfo) GetSchemas() []*Schema {
	if m != nil {
		return m.Schemas
	}
	return nil
}

type Schema struct {
	Name             string   `protobuf:"bytes,1,opt,name=name" json:"name"`
	Tables           []string `protobuf:"bytes,2,rep,name=tables" json:"tables"`
	NoLocks          bool     `protobuf:"varint,3,opt,name=noLocks" json:"noLocks"`
	WillSyncMore     bool     `protobuf:"varint,4,opt,name=willSyncMore" json:"willSyncMore"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *Schema) Reset()                    { *m = Schema{} }
func (m *Schema) String() string            { return proto.CompactTextString(m) }
func (*Schema) ProtoMessage()               {}
func (*Schema) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{11} }

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

func (m *Schema) GetTables() []string {
	if m != nil {
		return m.Tables
	}
	return nil
}

func (m *Schema) GetNoLocks() bool {
	if m != nil {
		return m.NoLocks
	}
	return false
}

func (m *Schema) GetWillSyncMore() bool {
	if m != nil {
		return m.WillSyncMore
	}
	return false
}

type SchemaDetail struct {
	// detail in JSON format.
	Detail           []byte `protobuf:"bytes,1,opt,name=detail" json:"detail"`
	Schema           string `protobuf:"bytes,2,opt,name=schema" json:"schema"`
	Table            string `protobuf:"bytes,3,opt,name=table" json:"table"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *SchemaDetail) Reset()                    { *m = SchemaDetail{} }
func (m *SchemaDetail) String() string            { return proto.CompactTextString(m) }
func (*SchemaDetail) ProtoMessage()               {}
func (*SchemaDetail) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{12} }

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

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

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

type Topic struct {
	Name             string `protobuf:"bytes,1,opt,name=name" json:"name"`
	Host             string `protobuf:"bytes,2,opt,name=host" json:"host"`
	Port             int32  `protobuf:"varint,3,opt,name=port" json:"port"`
	Schema           string `protobuf:"bytes,4,opt,name=schema" json:"schema"`
	Table            string `protobuf:"bytes,5,opt,name=table" json:"table"`
	PartitionNum     int32  `protobuf:"varint,6,opt,name=partition_num,json=partitionNum" json:"partition_num"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Topic) Reset()                    { *m = Topic{} }
func (m *Topic) String() string            { return proto.CompactTextString(m) }
func (*Topic) ProtoMessage()               {}
func (*Topic) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{13} }

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

func (m *Topic) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *Topic) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

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

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

func (m *Topic) GetPartitionNum() int32 {
	if m != nil {
		return m.PartitionNum
	}
	return 0
}

type Partition struct {
	TopicName        string    `protobuf:"bytes,1,opt,name=topic_name,json=topicName" json:"topic_name"`
	PartitionId      int32     `protobuf:"varint,2,opt,name=partition_id,json=partitionId" json:"partition_id"`
	Pos              *Position `protobuf:"bytes,3,opt,name=pos" json:"pos"`
	XXX_unrecognized []byte    `json:"-"`
}

func (m *Partition) Reset()                    { *m = Partition{} }
func (m *Partition) String() string            { return proto.CompactTextString(m) }
func (*Partition) ProtoMessage()               {}
func (*Partition) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{14} }

func (m *Partition) GetTopicName() string {
	if m != nil {
		return m.TopicName
	}
	return ""
}

func (m *Partition) GetPartitionId() int32 {
	if m != nil {
		return m.PartitionId
	}
	return 0
}

func (m *Partition) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

type Partitions struct {
	Partitions       []*Partition `protobuf:"bytes,1,rep,name=partitions" json:"partitions"`
	XXX_unrecognized []byte       `json:"-"`
}

func (m *Partitions) Reset()                    { *m = Partitions{} }
func (m *Partitions) String() string            { return proto.CompactTextString(m) }
func (*Partitions) ProtoMessage()               {}
func (*Partitions) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{15} }

func (m *Partitions) GetPartitions() []*Partition {
	if m != nil {
		return m.Partitions
	}
	return nil
}

type TopicPartitionBitmap struct {
	Topic                 *Topic   `protobuf:"bytes,1,opt,name=topic" json:"topic"`
	PartitionBitmap       []uint64 `protobuf:"varint,2,rep,name=partition_bitmap,json=partitionBitmap" json:"partition_bitmap"`
	PartitionMidwayBitmap []uint64 `protobuf:"varint,3,rep,name=partition_midway_bitmap,json=partitionMidwayBitmap" json:"partition_midway_bitmap"`
	XXX_unrecognized      []byte   `json:"-"`
}

func (m *TopicPartitionBitmap) Reset()                    { *m = TopicPartitionBitmap{} }
func (m *TopicPartitionBitmap) String() string            { return proto.CompactTextString(m) }
func (*TopicPartitionBitmap) ProtoMessage()               {}
func (*TopicPartitionBitmap) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{16} }

func (m *TopicPartitionBitmap) GetTopic() *Topic {
	if m != nil {
		return m.Topic
	}
	return nil
}

func (m *TopicPartitionBitmap) GetPartitionBitmap() []uint64 {
	if m != nil {
		return m.PartitionBitmap
	}
	return nil
}

func (m *TopicPartitionBitmap) GetPartitionMidwayBitmap() []uint64 {
	if m != nil {
		return m.PartitionMidwayBitmap
	}
	return nil
}

// Fence is a primitive to sync all consumers to consume old messages firstly
// use bitmap to mark which partition is already finished consuming [0,...,max patition ID]
type Fence struct {
	Id               uint64                  `protobuf:"varint,1,opt,name=id" json:"id"`
	Bitmaps          []*TopicPartitionBitmap `protobuf:"bytes,2,rep,name=bitmaps" json:"bitmaps"`
	XXX_unrecognized []byte                  `json:"-"`
}

func (m *Fence) Reset()                    { *m = Fence{} }
func (m *Fence) String() string            { return proto.CompactTextString(m) }
func (*Fence) ProtoMessage()               {}
func (*Fence) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{17} }

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

func (m *Fence) GetBitmaps() []*TopicPartitionBitmap {
	if m != nil {
		return m.Bitmaps
	}
	return nil
}

type DMLData struct {
	Schema           string     `protobuf:"bytes,1,opt,name=schema" json:"schema"`
	Table            string     `protobuf:"bytes,2,opt,name=table" json:"table"`
	Tp               EventType  `protobuf:"varint,3,opt,name=tp,enum=whpb.EventType" json:"tp"`
	Rows             []*RowData `protobuf:"bytes,4,rep,name=rows" json:"rows"`
	Columns          []*Column  `protobuf:"bytes,5,rep,name=columns" json:"columns"`
	XXX_unrecognized []byte     `json:"-"`
}

func (m *DMLData) Reset()                    { *m = DMLData{} }
func (m *DMLData) String() string            { return proto.CompactTextString(m) }
func (*DMLData) ProtoMessage()               {}
func (*DMLData) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{18} }

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

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

func (m *DMLData) GetTp() EventType {
	if m != nil {
		return m.Tp
	}
	return EventType_Insert
}

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

func (m *DMLData) GetColumns() []*Column {
	if m != nil {
		return m.Columns
	}
	return nil
}

type RowData struct {
	Row              []string `protobuf:"bytes,1,rep,name=row" json:"row"`
	XXX_unrecognized []byte   `json:"-"`
}

func (m *RowData) Reset()                    { *m = RowData{} }
func (m *RowData) String() string            { return proto.CompactTextString(m) }
func (*RowData) ProtoMessage()               {}
func (*RowData) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{19} }

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

type Column struct {
	Idx              int32  `protobuf:"varint,1,opt,name=idx" json:"idx"`
	Name             string `protobuf:"bytes,2,opt,name=name" json:"name"`
	IsKey            bool   `protobuf:"varint,3,opt,name=isKey" json:"isKey"`
	Type             int32  `protobuf:"varint,4,opt,name=type" json:"type"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Column) Reset()                    { *m = Column{} }
func (m *Column) String() string            { return proto.CompactTextString(m) }
func (*Column) ProtoMessage()               {}
func (*Column) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{20} }

func (m *Column) GetIdx() int32 {
	if m != nil {
		return m.Idx
	}
	return 0
}

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

func (m *Column) GetIsKey() bool {
	if m != nil {
		return m.IsKey
	}
	return false
}

func (m *Column) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

type Drip struct {
	Schema string     `protobuf:"bytes,1,opt,name=schema" json:"schema"`
	Table  string     `protobuf:"bytes,2,opt,name=table" json:"table"`
	Key    string     `protobuf:"bytes,3,opt,name=key" json:"key"`
	Source SourceType `protobuf:"varint,4,opt,name=source,enum=whpb.SourceType" json:"source"`
	Op     OPType     `protobuf:"varint,5,opt,name=op,enum=whpb.OPType" json:"op"`
	// dml data in this field of DML Drip event.
	Data []byte `protobuf:"bytes,6,opt,name=data" json:"data"`
	// fence id if op == DDL, fence.
	// ddl is a special fence, while we meet ddl, we should wait util all consumers reach all fence.
	// then we can agree to a person to do this ddl.
	FenceId uint64 `protobuf:"varint,7,opt,name=fence_id,json=fenceId" json:"fence_id"`
	// position of Drip event in log event
	Pos *Position `protobuf:"bytes,8,opt,name=pos" json:"pos"`
	// create time of Drip event.
	CreateTime       int64  `protobuf:"varint,9,opt,name=create_time,json=createTime" json:"create_time"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Drip) Reset()                    { *m = Drip{} }
func (m *Drip) String() string            { return proto.CompactTextString(m) }
func (*Drip) ProtoMessage()               {}
func (*Drip) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{21} }

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

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

func (m *Drip) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *Drip) GetSource() SourceType {
	if m != nil {
		return m.Source
	}
	return SourceType_mysql_binlog
}

func (m *Drip) GetOp() OPType {
	if m != nil {
		return m.Op
	}
	return OPType_DDL
}

func (m *Drip) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Drip) GetFenceId() uint64 {
	if m != nil {
		return m.FenceId
	}
	return 0
}

func (m *Drip) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *Drip) GetCreateTime() int64 {
	if m != nil {
		return m.CreateTime
	}
	return 0
}

func init() {
	proto.RegisterType((*Label)(nil), "whpb.Label")
	proto.RegisterType((*Worker)(nil), "whpb.Worker")
	proto.RegisterType((*Position)(nil), "whpb.Position")
	proto.RegisterType((*JobStatus)(nil), "whpb.JobStatus")
	proto.RegisterType((*Job)(nil), "whpb.Job")
	proto.RegisterType((*MysqlDumpJob)(nil), "whpb.MysqlDumpJob")
	proto.RegisterType((*MysqlBinlogJob)(nil), "whpb.MysqlBinlogJob")
	proto.RegisterType((*MysqlSyncJob)(nil), "whpb.MysqlSyncJob")
	proto.RegisterType((*DBAccount)(nil), "whpb.DBAccount")
	proto.RegisterType((*RouteRule)(nil), "whpb.RouteRule")
	proto.RegisterType((*SchemaInfo)(nil), "whpb.SchemaInfo")
	proto.RegisterType((*Schema)(nil), "whpb.Schema")
	proto.RegisterType((*SchemaDetail)(nil), "whpb.SchemaDetail")
	proto.RegisterType((*Topic)(nil), "whpb.Topic")
	proto.RegisterType((*Partition)(nil), "whpb.Partition")
	proto.RegisterType((*Partitions)(nil), "whpb.Partitions")
	proto.RegisterType((*TopicPartitionBitmap)(nil), "whpb.TopicPartitionBitmap")
	proto.RegisterType((*Fence)(nil), "whpb.Fence")
	proto.RegisterType((*DMLData)(nil), "whpb.DMLData")
	proto.RegisterType((*RowData)(nil), "whpb.RowData")
	proto.RegisterType((*Column)(nil), "whpb.Column")
	proto.RegisterType((*Drip)(nil), "whpb.Drip")
	proto.RegisterEnum("whpb.SourceType", SourceType_name, SourceType_value)
	proto.RegisterEnum("whpb.WorkerType", WorkerType_name, WorkerType_value)
	proto.RegisterEnum("whpb.OPType", OPType_name, OPType_value)
	proto.RegisterEnum("whpb.EventType", EventType_name, EventType_value)
	proto.RegisterEnum("whpb.JobState", JobState_name, JobState_value)
	proto.RegisterEnum("whpb.JobStage", JobStage_name, JobStage_value)
}
func (m *Label) 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 *Label) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Vals) > 0 {
		for _, s := range m.Vals {
			dAtA[i] = 0xa
			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 m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Worker) 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 *Worker) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Id))
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Type))
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x1a
			i++
			v := m.Labels[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovMetapb(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovMetapb(uint64(len(k))) + msgSize
			i = encodeVarintMetapb(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintMetapb(dAtA, i, uint64(v.Size()))
				n1, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n1
			}
		}
	}
	if len(m.Annotations) > 0 {
		for k, _ := range m.Annotations {
			dAtA[i] = 0x22
			i++
			v := m.Annotations[k]
			mapSize := 1 + len(k) + sovMetapb(uint64(len(k))) + 1 + len(v) + sovMetapb(uint64(len(v)))
			i = encodeVarintMetapb(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	dAtA[i] = 0x28
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.CreateTime))
	dAtA[i] = 0x30
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.LastTime))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Position) 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 *Position) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.MysqlBinlogFile)))
	i += copy(dAtA[i:], m.MysqlBinlogFile)
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.MysqlBinlogPos))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.MysqlBinlogGtid)))
	i += copy(dAtA[i:], m.MysqlBinlogGtid)
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.MongoTs))
	dAtA[i] = 0x28
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.KafkaOffset))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *JobStatus) 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 *JobStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Id))
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Stage))
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.State))
	dAtA[i] = 0x22
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Type)))
	i += copy(dAtA[i:], m.Type)
	dAtA[i] = 0x28
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Replicate))
	dAtA[i] = 0x30
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Total))
	dAtA[i] = 0x38
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Percent))
	if m.Pos != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(m.Pos.Size()))
		n2, err := m.Pos.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	dAtA[i] = 0x48
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Qps))
	if m.DelayMessageCount != nil {
		dAtA[i] = 0x50
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(*m.DelayMessageCount))
	}
	dAtA[i] = 0x5a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Message)))
	i += copy(dAtA[i:], m.Message)
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Job) 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 *Job) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Id))
	if m.Status != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(m.Status.Size()))
		n3, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Type))
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Source))
	if m.Info != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(len(m.Info)))
		i += copy(dAtA[i:], m.Info)
	}
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x32
			i++
			v := m.Labels[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovMetapb(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovMetapb(uint64(len(k))) + msgSize
			i = encodeVarintMetapb(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintMetapb(dAtA, i, uint64(v.Size()))
				n4, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n4
			}
		}
	}
	if len(m.Annotations) > 0 {
		for k, _ := range m.Annotations {
			dAtA[i] = 0x3a
			i++
			v := m.Annotations[k]
			mapSize := 1 + len(k) + sovMetapb(uint64(len(k))) + 1 + len(v) + sovMetapb(uint64(len(v)))
			i = encodeVarintMetapb(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if len(m.Dependencies) > 0 {
		for _, num := range m.Dependencies {
			dAtA[i] = 0x40
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(num))
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *MysqlDumpJob) 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 *MysqlDumpJob) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Source.Size()))
	n5, err := m.Source.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	if len(m.Schemas) > 0 {
		for _, msg := range m.Schemas {
			dAtA[i] = 0x12
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.PartitionNum))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *MysqlBinlogJob) 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 *MysqlBinlogJob) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Source.Size()))
	n6, err := m.Source.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	if len(m.Schemas) > 0 {
		for _, msg := range m.Schemas {
			dAtA[i] = 0x12
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.PartitionNum))
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.ServerId))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *MysqlSyncJob) 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 *MysqlSyncJob) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Source.Size()))
	n7, err := m.Source.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Target.Size()))
	n8, err := m.Target.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	if len(m.Rules) > 0 {
		for _, msg := range m.Rules {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DBAccount) 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 *DBAccount) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Host)))
	i += copy(dAtA[i:], m.Host)
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Port))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Username)))
	i += copy(dAtA[i:], m.Username)
	dAtA[i] = 0x22
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Password)))
	i += copy(dAtA[i:], m.Password)
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *RouteRule) 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 *RouteRule) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.SchemaPattern)))
	i += copy(dAtA[i:], m.SchemaPattern)
	if m.TablePattern != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(len(*m.TablePattern)))
		i += copy(dAtA[i:], *m.TablePattern)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.TargetSchema)))
	i += copy(dAtA[i:], m.TargetSchema)
	if m.TargetTable != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(len(*m.TargetTable)))
		i += copy(dAtA[i:], *m.TargetTable)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *SchemaInfo) 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 *SchemaInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Host)))
	i += copy(dAtA[i:], m.Host)
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Port))
	if len(m.Schemas) > 0 {
		for _, msg := range m.Schemas {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Schema) 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 *Schema) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	if len(m.Tables) > 0 {
		for _, s := range m.Tables {
			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)
		}
	}
	dAtA[i] = 0x18
	i++
	if m.NoLocks {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x20
	i++
	if m.WillSyncMore {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *SchemaDetail) 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 *SchemaDetail) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Detail != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(len(m.Detail)))
		i += copy(dAtA[i:], m.Detail)
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Schema)))
	i += copy(dAtA[i:], m.Schema)
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Table)))
	i += copy(dAtA[i:], m.Table)
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Topic) 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 *Topic) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Host)))
	i += copy(dAtA[i:], m.Host)
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Port))
	dAtA[i] = 0x22
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Schema)))
	i += copy(dAtA[i:], m.Schema)
	dAtA[i] = 0x2a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Table)))
	i += copy(dAtA[i:], m.Table)
	dAtA[i] = 0x30
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.PartitionNum))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Partition) 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 *Partition) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.TopicName)))
	i += copy(dAtA[i:], m.TopicName)
	dAtA[i] = 0x10
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.PartitionId))
	if m.Pos != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(m.Pos.Size()))
		n9, err := m.Pos.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *TopicPartitionBitmap) 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 *TopicPartitionBitmap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Topic != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(m.Topic.Size()))
		n10, err := m.Topic.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if len(m.PartitionBitmap) > 0 {
		for _, num := range m.PartitionBitmap {
			dAtA[i] = 0x10
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(num))
		}
	}
	if len(m.PartitionMidwayBitmap) > 0 {
		for _, num := range m.PartitionMidwayBitmap {
			dAtA[i] = 0x18
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(num))
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Fence) 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 *Fence) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Id))
	if len(m.Bitmaps) > 0 {
		for _, msg := range m.Bitmaps {
			dAtA[i] = 0x12
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DMLData) 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 *DMLData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Schema)))
	i += copy(dAtA[i:], m.Schema)
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Table)))
	i += copy(dAtA[i:], m.Table)
	dAtA[i] = 0x18
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Tp))
	if len(m.Rows) > 0 {
		for _, msg := range m.Rows {
			dAtA[i] = 0x22
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Columns) > 0 {
		for _, msg := range m.Columns {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintMetapb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *RowData) 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 *RowData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Row) > 0 {
		for _, s := range m.Row {
			dAtA[i] = 0xa
			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 m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Column) 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 *Column) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Idx))
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x18
	i++
	if m.IsKey {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Type))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Drip) 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 *Drip) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Schema)))
	i += copy(dAtA[i:], m.Schema)
	dAtA[i] = 0x12
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Table)))
	i += copy(dAtA[i:], m.Table)
	dAtA[i] = 0x1a
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(len(m.Key)))
	i += copy(dAtA[i:], m.Key)
	dAtA[i] = 0x20
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Source))
	dAtA[i] = 0x28
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.Op))
	if m.Data != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	dAtA[i] = 0x38
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.FenceId))
	if m.Pos != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintMetapb(dAtA, i, uint64(m.Pos.Size()))
		n11, err := m.Pos.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	dAtA[i] = 0x48
	i++
	i = encodeVarintMetapb(dAtA, i, uint64(m.CreateTime))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeFixed64Metapb(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Metapb(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintMetapb(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 *Label) Size() (n int) {
	var l int
	_ = l
	if len(m.Vals) > 0 {
		for _, s := range m.Vals {
			l = len(s)
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Worker) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovMetapb(uint64(m.Id))
	n += 1 + sovMetapb(uint64(m.Type))
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovMetapb(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovMetapb(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovMetapb(uint64(mapEntrySize))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovMetapb(uint64(len(k))) + 1 + len(v) + sovMetapb(uint64(len(v)))
			n += mapEntrySize + 1 + sovMetapb(uint64(mapEntrySize))
		}
	}
	n += 1 + sovMetapb(uint64(m.CreateTime))
	n += 1 + sovMetapb(uint64(m.LastTime))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Position) Size() (n int) {
	var l int
	_ = l
	l = len(m.MysqlBinlogFile)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.MysqlBinlogPos))
	l = len(m.MysqlBinlogGtid)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.MongoTs))
	n += 1 + sovMetapb(uint64(m.KafkaOffset))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *JobStatus) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovMetapb(uint64(m.Id))
	n += 1 + sovMetapb(uint64(m.Stage))
	n += 1 + sovMetapb(uint64(m.State))
	l = len(m.Type)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.Replicate))
	n += 1 + sovMetapb(uint64(m.Total))
	n += 1 + sovMetapb(uint64(m.Percent))
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovMetapb(uint64(l))
	}
	n += 1 + sovMetapb(uint64(m.Qps))
	if m.DelayMessageCount != nil {
		n += 1 + sovMetapb(uint64(*m.DelayMessageCount))
	}
	l = len(m.Message)
	n += 1 + l + sovMetapb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Job) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovMetapb(uint64(m.Id))
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovMetapb(uint64(l))
	}
	n += 1 + sovMetapb(uint64(m.Type))
	n += 1 + sovMetapb(uint64(m.Source))
	if m.Info != nil {
		l = len(m.Info)
		n += 1 + l + sovMetapb(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovMetapb(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovMetapb(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovMetapb(uint64(mapEntrySize))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovMetapb(uint64(len(k))) + 1 + len(v) + sovMetapb(uint64(len(v)))
			n += mapEntrySize + 1 + sovMetapb(uint64(mapEntrySize))
		}
	}
	if len(m.Dependencies) > 0 {
		for _, e := range m.Dependencies {
			n += 1 + sovMetapb(uint64(e))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MysqlDumpJob) Size() (n int) {
	var l int
	_ = l
	l = m.Source.Size()
	n += 1 + l + sovMetapb(uint64(l))
	if len(m.Schemas) > 0 {
		for _, e := range m.Schemas {
			l = e.Size()
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	n += 1 + sovMetapb(uint64(m.PartitionNum))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MysqlBinlogJob) Size() (n int) {
	var l int
	_ = l
	l = m.Source.Size()
	n += 1 + l + sovMetapb(uint64(l))
	if len(m.Schemas) > 0 {
		for _, e := range m.Schemas {
			l = e.Size()
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	n += 1 + sovMetapb(uint64(m.PartitionNum))
	n += 1 + sovMetapb(uint64(m.ServerId))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MysqlSyncJob) Size() (n int) {
	var l int
	_ = l
	l = m.Source.Size()
	n += 1 + l + sovMetapb(uint64(l))
	l = m.Target.Size()
	n += 1 + l + sovMetapb(uint64(l))
	if len(m.Rules) > 0 {
		for _, e := range m.Rules {
			l = e.Size()
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DBAccount) Size() (n int) {
	var l int
	_ = l
	l = len(m.Host)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.Port))
	l = len(m.Username)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Password)
	n += 1 + l + sovMetapb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RouteRule) Size() (n int) {
	var l int
	_ = l
	l = len(m.SchemaPattern)
	n += 1 + l + sovMetapb(uint64(l))
	if m.TablePattern != nil {
		l = len(*m.TablePattern)
		n += 1 + l + sovMetapb(uint64(l))
	}
	l = len(m.TargetSchema)
	n += 1 + l + sovMetapb(uint64(l))
	if m.TargetTable != nil {
		l = len(*m.TargetTable)
		n += 1 + l + sovMetapb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SchemaInfo) Size() (n int) {
	var l int
	_ = l
	l = len(m.Host)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.Port))
	if len(m.Schemas) > 0 {
		for _, e := range m.Schemas {
			l = e.Size()
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Schema) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovMetapb(uint64(l))
	if len(m.Tables) > 0 {
		for _, s := range m.Tables {
			l = len(s)
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	n += 2
	n += 2
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SchemaDetail) Size() (n int) {
	var l int
	_ = l
	if m.Detail != nil {
		l = len(m.Detail)
		n += 1 + l + sovMetapb(uint64(l))
	}
	l = len(m.Schema)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Table)
	n += 1 + l + sovMetapb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Topic) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Host)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.Port))
	l = len(m.Schema)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Table)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.PartitionNum))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Partition) Size() (n int) {
	var l int
	_ = l
	l = len(m.TopicName)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.PartitionId))
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovMetapb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *TopicPartitionBitmap) Size() (n int) {
	var l int
	_ = l
	if m.Topic != nil {
		l = m.Topic.Size()
		n += 1 + l + sovMetapb(uint64(l))
	}
	if len(m.PartitionBitmap) > 0 {
		for _, e := range m.PartitionBitmap {
			n += 1 + sovMetapb(uint64(e))
		}
	}
	if len(m.PartitionMidwayBitmap) > 0 {
		for _, e := range m.PartitionMidwayBitmap {
			n += 1 + sovMetapb(uint64(e))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *DMLData) Size() (n int) {
	var l int
	_ = l
	l = len(m.Schema)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Table)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.Tp))
	if len(m.Rows) > 0 {
		for _, e := range m.Rows {
			l = e.Size()
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	if len(m.Columns) > 0 {
		for _, e := range m.Columns {
			l = e.Size()
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RowData) Size() (n int) {
	var l int
	_ = l
	if len(m.Row) > 0 {
		for _, s := range m.Row {
			l = len(s)
			n += 1 + l + sovMetapb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Column) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovMetapb(uint64(m.Idx))
	l = len(m.Name)
	n += 1 + l + sovMetapb(uint64(l))
	n += 2
	n += 1 + sovMetapb(uint64(m.Type))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Drip) Size() (n int) {
	var l int
	_ = l
	l = len(m.Schema)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Table)
	n += 1 + l + sovMetapb(uint64(l))
	l = len(m.Key)
	n += 1 + l + sovMetapb(uint64(l))
	n += 1 + sovMetapb(uint64(m.Source))
	n += 1 + sovMetapb(uint64(m.Op))
	if m.Data != nil {
		l = len(m.Data)
		n += 1 + l + sovMetapb(uint64(l))
	}
	n += 1 + sovMetapb(uint64(m.FenceId))
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovMetapb(uint64(l))
	}
	n += 1 + sovMetapb(uint64(m.CreateTime))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Worker) 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 ErrIntOverflowMetapb
			}
			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: Worker: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Worker: 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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (WorkerType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var stringLenmapkey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLenmapkey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLenmapkey := int(stringLenmapkey)
			if intStringLenmapkey < 0 {
				return ErrInvalidLengthMetapb
			}
			postStringIndexmapkey := iNdEx + intStringLenmapkey
			if postStringIndexmapkey > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.Labels == nil {
				m.Labels = make(map[string]*Label)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthMetapb
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthMetapb
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &Label{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Labels[mapkey] = mapvalue
			} else {
				var mapvalue *Label
				m.Labels[mapkey] = mapvalue
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var stringLenmapkey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLenmapkey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLenmapkey := int(stringLenmapkey)
			if intStringLenmapkey < 0 {
				return ErrInvalidLengthMetapb
			}
			postStringIndexmapkey := iNdEx + intStringLenmapkey
			if postStringIndexmapkey > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var stringLenmapvalue uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLenmapvalue := int(stringLenmapvalue)
				if intStringLenmapvalue < 0 {
					return ErrInvalidLengthMetapb
				}
				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
				if postStringIndexmapvalue > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
				iNdEx = postStringIndexmapvalue
				m.Annotations[mapkey] = mapvalue
			} else {
				var mapvalue string
				m.Annotations[mapkey] = mapvalue
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
			}
			m.CreateTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTime", wireType)
			}
			m.LastTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Position) 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 ErrIntOverflowMetapb
			}
			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: Position: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MysqlBinlogFile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MysqlBinlogFile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MysqlBinlogPos", wireType)
			}
			m.MysqlBinlogPos = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MysqlBinlogPos |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MysqlBinlogGtid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MysqlBinlogGtid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MongoTs", wireType)
			}
			m.MongoTs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MongoTs |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KafkaOffset", wireType)
			}
			m.KafkaOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KafkaOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobStatus) 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 ErrIntOverflowMetapb
			}
			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: JobStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobStatus: 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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (uint64(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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stage |= (JobStage(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= (JobState(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicate", wireType)
			}
			m.Replicate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicate |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percent", wireType)
			}
			m.Percent = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Percent |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Qps", wireType)
			}
			m.Qps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Qps |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayMessageCount", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DelayMessageCount = &v
		case 11:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Job) 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 ErrIntOverflowMetapb
			}
			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: Job: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Job: 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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &JobStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (WorkerType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			m.Source = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= (SourceType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Info = append(m.Info[:0], dAtA[iNdEx:postIndex]...)
			if m.Info == nil {
				m.Info = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var stringLenmapkey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLenmapkey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLenmapkey := int(stringLenmapkey)
			if intStringLenmapkey < 0 {
				return ErrInvalidLengthMetapb
			}
			postStringIndexmapkey := iNdEx + intStringLenmapkey
			if postStringIndexmapkey > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.Labels == nil {
				m.Labels = make(map[string]*Label)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapmsglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					mapmsglen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if mapmsglen < 0 {
					return ErrInvalidLengthMetapb
				}
				postmsgIndex := iNdEx + mapmsglen
				if mapmsglen < 0 {
					return ErrInvalidLengthMetapb
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &Label{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Labels[mapkey] = mapvalue
			} else {
				var mapvalue *Label
				m.Labels[mapkey] = mapvalue
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var stringLenmapkey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLenmapkey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLenmapkey := int(stringLenmapkey)
			if intStringLenmapkey < 0 {
				return ErrInvalidLengthMetapb
			}
			postStringIndexmapkey := iNdEx + intStringLenmapkey
			if postStringIndexmapkey > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var stringLenmapvalue uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLenmapvalue := int(stringLenmapvalue)
				if intStringLenmapvalue < 0 {
					return ErrInvalidLengthMetapb
				}
				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
				if postStringIndexmapvalue > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
				iNdEx = postStringIndexmapvalue
				m.Annotations[mapkey] = mapvalue
			} else {
				var mapvalue string
				m.Annotations[mapkey] = mapvalue
			}
			iNdEx = postIndex
		case 8:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Dependencies = append(m.Dependencies, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMetapb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetapb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Dependencies = append(m.Dependencies, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MysqlBinlogJob) 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 ErrIntOverflowMetapb
			}
			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: MysqlBinlogJob: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MysqlBinlogJob: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schemas = append(m.Schemas, &Schema{})
			if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionNum", wireType)
			}
			m.PartitionNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PartitionNum |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
			}
			m.ServerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ServerId |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DBAccount) 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 ErrIntOverflowMetapb
			}
			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: DBAccount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBAccount: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Host = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Password = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouteRule) 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 ErrIntOverflowMetapb
			}
			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: RouteRule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouteRule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaPattern", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SchemaPattern = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TablePattern", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.TablePattern = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetSchema", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetSchema = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetTable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.TargetTable = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SchemaInfo) 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 ErrIntOverflowMetapb
			}
			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: SchemaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Host = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schemas = append(m.Schemas, &Schema{})
			if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Schema) 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 ErrIntOverflowMetapb
			}
			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: Schema: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Schema: 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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tables = append(m.Tables, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoLocks", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoLocks = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WillSyncMore", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.WillSyncMore = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SchemaDetail) 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 ErrIntOverflowMetapb
			}
			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: SchemaDetail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaDetail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Detail = append(m.Detail[:0], dAtA[iNdEx:postIndex]...)
			if m.Detail == nil {
				m.Detail = []byte{}
			}
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Topic) 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 ErrIntOverflowMetapb
			}
			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: Topic: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Topic: 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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Host = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schema = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionNum", wireType)
			}
			m.PartitionNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PartitionNum |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Partition) 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 ErrIntOverflowMetapb
			}
			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: Partition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Partition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionId", wireType)
			}
			m.PartitionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PartitionId |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TopicPartitionBitmap) 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 ErrIntOverflowMetapb
			}
			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: TopicPartitionBitmap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TopicPartitionBitmap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Topic == nil {
				m.Topic = &Topic{}
			}
			if err := m.Topic.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PartitionBitmap = append(m.PartitionBitmap, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMetapb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetapb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PartitionBitmap = append(m.PartitionBitmap, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionBitmap", wireType)
			}
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PartitionMidwayBitmap = append(m.PartitionMidwayBitmap, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetapb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMetapb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetapb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PartitionMidwayBitmap = append(m.PartitionMidwayBitmap, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionMidwayBitmap", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fence) 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 ErrIntOverflowMetapb
			}
			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: Fence: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fence: 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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bitmaps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bitmaps = append(m.Bitmaps, &TopicPartitionBitmap{})
			if err := m.Bitmaps[len(m.Bitmaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DMLData) 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 ErrIntOverflowMetapb
			}
			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: DMLData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DMLData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schema = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType)
			}
			m.Tp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tp |= (EventType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Rows = append(m.Rows, &RowData{})
			if err := m.Rows[len(m.Rows)-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 Columns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Columns = append(m.Columns, &Column{})
			if err := m.Columns[len(m.Columns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Column) 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 ErrIntOverflowMetapb
			}
			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: Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idx", wireType)
			}
			m.Idx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Idx |= (int32(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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsKey", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsKey = bool(v != 0)
		case 4:
			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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Drip) 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 ErrIntOverflowMetapb
			}
			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: Drip: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Drip: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schema = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				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 ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			m.Source = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= (SourceType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= (OPType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FenceId", wireType)
			}
			m.FenceId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FenceId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetapb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
			}
			m.CreateTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetapb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetapb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetapb(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, ErrIntOverflowMetapb
			}
			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, ErrIntOverflowMetapb
				}
				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, ErrIntOverflowMetapb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthMetapb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowMetapb
					}
					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 := skipMetapb(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

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

func init() { proto.RegisterFile("metapb.proto", fileDescriptorMetapb) }

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