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

/*
	Package whpb is a generated protocol buffer package.

	It is generated from these files:
		etherpb.proto

	It has these top-level messages:
		Error
		RequestHeader
		ResponseHeader
		WorkerHeartbeatRequest
		WorkerHeartbeatResponse
		RegisterWorkerRequest
		RegisterWorkerResponse
		RenewJobRequest
		RenewJobResponse
		GetClusterInfoRequest
		GetClusterInfoResponse
		CreateFenceRequest
		CreateFenceResponse
		WaitOnFenceRequest
		WaitOnFenceResponse
		Member
*/
package whpb

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

type ErrorCode int32

const (
	ErrorCode_NotBootStrapped ErrorCode = 0
	ErrorCode_NotLeader       ErrorCode = 1
	ErrorCode_ContractExipred ErrorCode = 2
	ErrorCode_RenewContract   ErrorCode = 3
	ErrorCode_CreateNewWorker ErrorCode = 4
	ErrorCode_CreateNewFence  ErrorCode = 5
	ErrorCode_Unknown         ErrorCode = 6
)

var ErrorCode_name = map[int32]string{
	0: "NotBootStrapped",
	1: "NotLeader",
	2: "ContractExipred",
	3: "RenewContract",
	4: "CreateNewWorker",
	5: "CreateNewFence",
	6: "Unknown",
}
var ErrorCode_value = map[string]int32{
	"NotBootStrapped": 0,
	"NotLeader":       1,
	"ContractExipred": 2,
	"RenewContract":   3,
	"CreateNewWorker": 4,
	"CreateNewFence":  5,
	"Unknown":         6,
}

func (x ErrorCode) String() string {
	return proto.EnumName(ErrorCode_name, int32(x))
}
func (ErrorCode) EnumDescriptor() ([]byte, []int) { return fileDescriptorEtherpb, []int{0} }

type Error struct {
	Errcode ErrorCode `protobuf:"varint,1,opt,name=errcode,proto3,enum=whpb.ErrorCode" json:"errcode"`
	Message string    `protobuf:"bytes,2,opt,name=message,proto3" json:"message"`
}

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

func (m *Error) GetErrcode() ErrorCode {
	if m != nil {
		return m.Errcode
	}
	return ErrorCode_NotBootStrapped
}

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

type RequestHeader struct {
	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id"`
	WorkerId  uint64 `protobuf:"varint,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id"`
}

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

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

func (m *RequestHeader) GetWorkerId() uint64 {
	if m != nil {
		return m.WorkerId
	}
	return 0
}

type ResponseHeader struct {
	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id"`
	WorkerId  uint64 `protobuf:"varint,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id"`
	Error     *Error `protobuf:"bytes,3,opt,name=error" json:"error"`
}

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

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

func (m *ResponseHeader) GetWorkerId() uint64 {
	if m != nil {
		return m.WorkerId
	}
	return 0
}

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

type WorkerHeartbeatRequest struct {
	Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	// worker should report all jobs that it works on.
	Jobs []*JobStatus `protobuf:"bytes,2,rep,name=jobs" json:"jobs"`
}

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

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

func (m *WorkerHeartbeatRequest) GetJobs() []*JobStatus {
	if m != nil {
		return m.Jobs
	}
	return nil
}

type WorkerHeartbeatResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	// new jobs that ether-client assigns to worker.
	NewJobs []*Job `protobuf:"bytes,2,rep,name=new_jobs,json=newJobs" json:"new_jobs"`
	// obsolete jobs that worker would give up.
	ObsoleteJobIds []uint64 `protobuf:"varint,3,rep,packed,name=obsolete_job_ids,json=obsoleteJobIds" json:"obsolete_job_ids"`
}

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

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

func (m *WorkerHeartbeatResponse) GetNewJobs() []*Job {
	if m != nil {
		return m.NewJobs
	}
	return nil
}

func (m *WorkerHeartbeatResponse) GetObsoleteJobIds() []uint64 {
	if m != nil {
		return m.ObsoleteJobIds
	}
	return nil
}

type RegisterWorkerRequest struct {
	Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	Worker *Worker        `protobuf:"bytes,2,opt,name=worker" json:"worker"`
}

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

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

func (m *RegisterWorkerRequest) GetWorker() *Worker {
	if m != nil {
		return m.Worker
	}
	return nil
}

type RegisterWorkerResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
}

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

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

type RenewJobRequest struct {
	Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	JobIds []uint64       `protobuf:"varint,2,rep,packed,name=job_ids,json=jobIds" json:"job_ids"`
	Lease  int64          `protobuf:"varint,3,opt,name=lease,proto3" json:"lease"`
}

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

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

func (m *RenewJobRequest) GetJobIds() []uint64 {
	if m != nil {
		return m.JobIds
	}
	return nil
}

func (m *RenewJobRequest) GetLease() int64 {
	if m != nil {
		return m.Lease
	}
	return 0
}

type RenewJobResponse struct {
	Header      *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	ExpiredJobs []uint64        `protobuf:"varint,2,rep,packed,name=expiredJobs" json:"expiredJobs"`
	ErrorJobs   []uint64        `protobuf:"varint,3,rep,packed,name=errorJobs" json:"errorJobs"`
}

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

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

func (m *RenewJobResponse) GetExpiredJobs() []uint64 {
	if m != nil {
		return m.ExpiredJobs
	}
	return nil
}

func (m *RenewJobResponse) GetErrorJobs() []uint64 {
	if m != nil {
		return m.ErrorJobs
	}
	return nil
}

type GetClusterInfoRequest struct {
}

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

type GetClusterInfoResponse struct {
	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id"`
	// key prefix in storage.
	StorageRootPath string    `protobuf:"bytes,2,opt,name=storage_root_path,json=storageRootPath,proto3" json:"storage_root_path"`
	Leader          *Member   `protobuf:"bytes,3,opt,name=leader" json:"leader"`
	Members         []*Member `protobuf:"bytes,4,rep,name=members" json:"members"`
}

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

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

func (m *GetClusterInfoResponse) GetStorageRootPath() string {
	if m != nil {
		return m.StorageRootPath
	}
	return ""
}

func (m *GetClusterInfoResponse) GetLeader() *Member {
	if m != nil {
		return m.Leader
	}
	return nil
}

func (m *GetClusterInfoResponse) GetMembers() []*Member {
	if m != nil {
		return m.Members
	}
	return nil
}

type CreateFenceRequest struct {
	Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	Topics []*Topic       `protobuf:"bytes,2,rep,name=topics" json:"topics"`
}

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

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

func (m *CreateFenceRequest) GetTopics() []*Topic {
	if m != nil {
		return m.Topics
	}
	return nil
}

type CreateFenceResponse struct {
	Header  *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	FenceId uint64          `protobuf:"varint,2,opt,name=fence_id,json=fenceId,proto3" json:"fence_id"`
}

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

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

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

type WaitOnFenceRequest struct {
	Header     *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	FenceId    uint64         `protobuf:"varint,2,opt,name=fence_id,json=fenceId,proto3" json:"fence_id"`
	JobId      uint64         `protobuf:"varint,3,opt,name=job_id,json=jobId,proto3" json:"job_id"`
	Topic      *Topic         `protobuf:"bytes,4,opt,name=topic" json:"topic"`
	Partitions []int32        `protobuf:"varint,5,rep,packed,name=partitions" json:"partitions"`
}

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

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

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

func (m *WaitOnFenceRequest) GetJobId() uint64 {
	if m != nil {
		return m.JobId
	}
	return 0
}

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

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

type WaitOnFenceResponse struct {
	Header   *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	IsSynced bool            `protobuf:"varint,2,opt,name=isSynced,proto3" json:"isSynced"`
}

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

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

func (m *WaitOnFenceResponse) GetIsSynced() bool {
	if m != nil {
		return m.IsSynced
	}
	return false
}

type Member struct {
	// name is the name of the ether-client member.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name"`
	// member_id is the unique id of the ether-client member.
	MemberId   uint64   `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id"`
	PeerUrls   []string `protobuf:"bytes,3,rep,name=peer_urls,json=peerUrls" json:"peer_urls"`
	ClientUrls []string `protobuf:"bytes,4,rep,name=client_urls,json=clientUrls" json:"client_urls"`
}

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

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

func (m *Member) GetMemberId() uint64 {
	if m != nil {
		return m.MemberId
	}
	return 0
}

func (m *Member) GetPeerUrls() []string {
	if m != nil {
		return m.PeerUrls
	}
	return nil
}

func (m *Member) GetClientUrls() []string {
	if m != nil {
		return m.ClientUrls
	}
	return nil
}

func init() {
	proto.RegisterType((*Error)(nil), "whpb.Error")
	proto.RegisterType((*RequestHeader)(nil), "whpb.RequestHeader")
	proto.RegisterType((*ResponseHeader)(nil), "whpb.ResponseHeader")
	proto.RegisterType((*WorkerHeartbeatRequest)(nil), "whpb.WorkerHeartbeatRequest")
	proto.RegisterType((*WorkerHeartbeatResponse)(nil), "whpb.WorkerHeartbeatResponse")
	proto.RegisterType((*RegisterWorkerRequest)(nil), "whpb.RegisterWorkerRequest")
	proto.RegisterType((*RegisterWorkerResponse)(nil), "whpb.RegisterWorkerResponse")
	proto.RegisterType((*RenewJobRequest)(nil), "whpb.RenewJobRequest")
	proto.RegisterType((*RenewJobResponse)(nil), "whpb.RenewJobResponse")
	proto.RegisterType((*GetClusterInfoRequest)(nil), "whpb.GetClusterInfoRequest")
	proto.RegisterType((*GetClusterInfoResponse)(nil), "whpb.GetClusterInfoResponse")
	proto.RegisterType((*CreateFenceRequest)(nil), "whpb.CreateFenceRequest")
	proto.RegisterType((*CreateFenceResponse)(nil), "whpb.CreateFenceResponse")
	proto.RegisterType((*WaitOnFenceRequest)(nil), "whpb.WaitOnFenceRequest")
	proto.RegisterType((*WaitOnFenceResponse)(nil), "whpb.WaitOnFenceResponse")
	proto.RegisterType((*Member)(nil), "whpb.Member")
	proto.RegisterEnum("whpb.ErrorCode", ErrorCode_name, ErrorCode_value)
}

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

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

// Client API for Ether service

type EtherClient interface {
	// WorkerHeartbeat represents heartbeat interface interacted with ether-client server.
	WorkerHeartbeat(ctx context.Context, opts ...grpc.CallOption) (Ether_WorkerHeartbeatClient, error)
	// RegisterWorker registers worker
	RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error)
	// RenewJob renews job lease.
	// if we fail to renew job in lease, we should give up this job.
	RenewJob(ctx context.Context, in *RenewJobRequest, opts ...grpc.CallOption) (*RenewJobResponse, error)
	// GetClusterInfo returns cluster info.
	GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error)
	// CreateFence creates fence under one topic.
	CreateFence(ctx context.Context, in *CreateFenceRequest, opts ...grpc.CallOption) (*CreateFenceResponse, error)
	// WaitOnFence waits on it's fences util all consumers reach all fences.
	WaitOnFenceMidway(ctx context.Context, in *WaitOnFenceRequest, opts ...grpc.CallOption) (Ether_WaitOnFenceMidwayClient, error)
	WaitOnFenceFinal(ctx context.Context, in *WaitOnFenceRequest, opts ...grpc.CallOption) (Ether_WaitOnFenceFinalClient, error)
}

type etherClient struct {
	cc *grpc.ClientConn
}

func NewEtherClient(cc *grpc.ClientConn) EtherClient {
	return &etherClient{cc}
}

func (c *etherClient) WorkerHeartbeat(ctx context.Context, opts ...grpc.CallOption) (Ether_WorkerHeartbeatClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Ether_serviceDesc.Streams[0], c.cc, "/whpb.Ether/WorkerHeartbeat", opts...)
	if err != nil {
		return nil, err
	}
	x := &etherWorkerHeartbeatClient{stream}
	return x, nil
}

type Ether_WorkerHeartbeatClient interface {
	Send(*WorkerHeartbeatRequest) error
	Recv() (*WorkerHeartbeatResponse, error)
	grpc.ClientStream
}

type etherWorkerHeartbeatClient struct {
	grpc.ClientStream
}

func (x *etherWorkerHeartbeatClient) Send(m *WorkerHeartbeatRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *etherClient) RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error) {
	out := new(RegisterWorkerResponse)
	err := grpc.Invoke(ctx, "/whpb.Ether/RegisterWorker", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *etherClient) RenewJob(ctx context.Context, in *RenewJobRequest, opts ...grpc.CallOption) (*RenewJobResponse, error) {
	out := new(RenewJobResponse)
	err := grpc.Invoke(ctx, "/whpb.Ether/RenewJob", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *etherClient) GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) {
	out := new(GetClusterInfoResponse)
	err := grpc.Invoke(ctx, "/whpb.Ether/GetClusterInfo", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *etherClient) CreateFence(ctx context.Context, in *CreateFenceRequest, opts ...grpc.CallOption) (*CreateFenceResponse, error) {
	out := new(CreateFenceResponse)
	err := grpc.Invoke(ctx, "/whpb.Ether/CreateFence", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *etherClient) WaitOnFenceMidway(ctx context.Context, in *WaitOnFenceRequest, opts ...grpc.CallOption) (Ether_WaitOnFenceMidwayClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Ether_serviceDesc.Streams[1], c.cc, "/whpb.Ether/WaitOnFenceMidway", opts...)
	if err != nil {
		return nil, err
	}
	x := &etherWaitOnFenceMidwayClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Ether_WaitOnFenceMidwayClient interface {
	Recv() (*WaitOnFenceResponse, error)
	grpc.ClientStream
}

type etherWaitOnFenceMidwayClient struct {
	grpc.ClientStream
}

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

func (c *etherClient) WaitOnFenceFinal(ctx context.Context, in *WaitOnFenceRequest, opts ...grpc.CallOption) (Ether_WaitOnFenceFinalClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Ether_serviceDesc.Streams[2], c.cc, "/whpb.Ether/WaitOnFenceFinal", opts...)
	if err != nil {
		return nil, err
	}
	x := &etherWaitOnFenceFinalClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Ether_WaitOnFenceFinalClient interface {
	Recv() (*WaitOnFenceResponse, error)
	grpc.ClientStream
}

type etherWaitOnFenceFinalClient struct {
	grpc.ClientStream
}

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

// Server API for Ether service

type EtherServer interface {
	// WorkerHeartbeat represents heartbeat interface interacted with ether-client server.
	WorkerHeartbeat(Ether_WorkerHeartbeatServer) error
	// RegisterWorker registers worker
	RegisterWorker(context.Context, *RegisterWorkerRequest) (*RegisterWorkerResponse, error)
	// RenewJob renews job lease.
	// if we fail to renew job in lease, we should give up this job.
	RenewJob(context.Context, *RenewJobRequest) (*RenewJobResponse, error)
	// GetClusterInfo returns cluster info.
	GetClusterInfo(context.Context, *GetClusterInfoRequest) (*GetClusterInfoResponse, error)
	// CreateFence creates fence under one topic.
	CreateFence(context.Context, *CreateFenceRequest) (*CreateFenceResponse, error)
	// WaitOnFence waits on it's fences util all consumers reach all fences.
	WaitOnFenceMidway(*WaitOnFenceRequest, Ether_WaitOnFenceMidwayServer) error
	WaitOnFenceFinal(*WaitOnFenceRequest, Ether_WaitOnFenceFinalServer) error
}

func RegisterEtherServer(s *grpc.Server, srv EtherServer) {
	s.RegisterService(&_Ether_serviceDesc, srv)
}

func _Ether_WorkerHeartbeat_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(EtherServer).WorkerHeartbeat(&etherWorkerHeartbeatServer{stream})
}

type Ether_WorkerHeartbeatServer interface {
	Send(*WorkerHeartbeatResponse) error
	Recv() (*WorkerHeartbeatRequest, error)
	grpc.ServerStream
}

type etherWorkerHeartbeatServer struct {
	grpc.ServerStream
}

func (x *etherWorkerHeartbeatServer) Send(m *WorkerHeartbeatResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Ether_RegisterWorker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterWorkerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EtherServer).RegisterWorker(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/whpb.Ether/RegisterWorker",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EtherServer).RegisterWorker(ctx, req.(*RegisterWorkerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ether_RenewJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenewJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EtherServer).RenewJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/whpb.Ether/RenewJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EtherServer).RenewJob(ctx, req.(*RenewJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ether_GetClusterInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EtherServer).GetClusterInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/whpb.Ether/GetClusterInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EtherServer).GetClusterInfo(ctx, req.(*GetClusterInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ether_CreateFence_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateFenceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EtherServer).CreateFence(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/whpb.Ether/CreateFence",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EtherServer).CreateFence(ctx, req.(*CreateFenceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ether_WaitOnFenceMidway_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WaitOnFenceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EtherServer).WaitOnFenceMidway(m, &etherWaitOnFenceMidwayServer{stream})
}

type Ether_WaitOnFenceMidwayServer interface {
	Send(*WaitOnFenceResponse) error
	grpc.ServerStream
}

type etherWaitOnFenceMidwayServer struct {
	grpc.ServerStream
}

func (x *etherWaitOnFenceMidwayServer) Send(m *WaitOnFenceResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Ether_WaitOnFenceFinal_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WaitOnFenceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EtherServer).WaitOnFenceFinal(m, &etherWaitOnFenceFinalServer{stream})
}

type Ether_WaitOnFenceFinalServer interface {
	Send(*WaitOnFenceResponse) error
	grpc.ServerStream
}

type etherWaitOnFenceFinalServer struct {
	grpc.ServerStream
}

func (x *etherWaitOnFenceFinalServer) Send(m *WaitOnFenceResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _Ether_serviceDesc = grpc.ServiceDesc{
	ServiceName: "whpb.Ether",
	HandlerType: (*EtherServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterWorker",
			Handler:    _Ether_RegisterWorker_Handler,
		},
		{
			MethodName: "RenewJob",
			Handler:    _Ether_RenewJob_Handler,
		},
		{
			MethodName: "GetClusterInfo",
			Handler:    _Ether_GetClusterInfo_Handler,
		},
		{
			MethodName: "CreateFence",
			Handler:    _Ether_CreateFence_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WorkerHeartbeat",
			Handler:       _Ether_WorkerHeartbeat_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "WaitOnFenceMidway",
			Handler:       _Ether_WaitOnFenceMidway_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WaitOnFenceFinal",
			Handler:       _Ether_WaitOnFenceFinal_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "etherpb.proto",
}

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

func (m *Error) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Errcode != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Errcode))
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	return i, nil
}

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

func (m *ResponseHeader) 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 *ResponseHeader) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ClusterId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.ClusterId))
	}
	if m.WorkerId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.WorkerId))
	}
	if m.Error != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Error.Size()))
		n1, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

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

func (m *WorkerHeartbeatResponse) 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 *WorkerHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n3, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if len(m.NewJobs) > 0 {
		for _, msg := range m.NewJobs {
			dAtA[i] = 0x12
			i++
			i = encodeVarintEtherpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.ObsoleteJobIds) > 0 {
		dAtA5 := make([]byte, len(m.ObsoleteJobIds)*10)
		var j4 int
		for _, num := range m.ObsoleteJobIds {
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(j4))
		i += copy(dAtA[i:], dAtA5[:j4])
	}
	return i, nil
}

func (m *RegisterWorkerRequest) 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 *RegisterWorkerRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n6, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.Worker != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Worker.Size()))
		n7, err := m.Worker.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}

func (m *RegisterWorkerResponse) 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 *RegisterWorkerResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n8, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}

func (m *RenewJobRequest) 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 *RenewJobRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n9, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if len(m.JobIds) > 0 {
		dAtA11 := make([]byte, len(m.JobIds)*10)
		var j10 int
		for _, num := range m.JobIds {
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(j10))
		i += copy(dAtA[i:], dAtA11[:j10])
	}
	if m.Lease != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Lease))
	}
	return i, nil
}

func (m *RenewJobResponse) 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 *RenewJobResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n12, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if len(m.ExpiredJobs) > 0 {
		dAtA14 := make([]byte, len(m.ExpiredJobs)*10)
		var j13 int
		for _, num := range m.ExpiredJobs {
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(j13))
		i += copy(dAtA[i:], dAtA14[:j13])
	}
	if len(m.ErrorJobs) > 0 {
		dAtA16 := make([]byte, len(m.ErrorJobs)*10)
		var j15 int
		for _, num := range m.ErrorJobs {
			for num >= 1<<7 {
				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j15++
			}
			dAtA16[j15] = uint8(num)
			j15++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(j15))
		i += copy(dAtA[i:], dAtA16[:j15])
	}
	return i, nil
}

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

func (m *GetClusterInfoResponse) 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 *GetClusterInfoResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ClusterId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.ClusterId))
	}
	if len(m.StorageRootPath) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(len(m.StorageRootPath)))
		i += copy(dAtA[i:], m.StorageRootPath)
	}
	if m.Leader != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Leader.Size()))
		n17, err := m.Leader.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if len(m.Members) > 0 {
		for _, msg := range m.Members {
			dAtA[i] = 0x22
			i++
			i = encodeVarintEtherpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *CreateFenceResponse) 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 *CreateFenceResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n19, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if m.FenceId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.FenceId))
	}
	return i, nil
}

func (m *WaitOnFenceRequest) 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 *WaitOnFenceRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n20, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if m.FenceId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.FenceId))
	}
	if m.JobId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.JobId))
	}
	if m.Topic != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Topic.Size()))
		n21, err := m.Topic.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if len(m.Partitions) > 0 {
		dAtA23 := make([]byte, len(m.Partitions)*10)
		var j22 int
		for _, num1 := range m.Partitions {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j22++
			}
			dAtA23[j22] = uint8(num)
			j22++
		}
		dAtA[i] = 0x2a
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(j22))
		i += copy(dAtA[i:], dAtA23[:j22])
	}
	return i, nil
}

func (m *WaitOnFenceResponse) 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 *WaitOnFenceResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEtherpb(dAtA, i, uint64(m.Header.Size()))
		n24, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	if m.IsSynced {
		dAtA[i] = 0x10
		i++
		if m.IsSynced {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

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

func encodeFixed64Etherpb(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 encodeFixed32Etherpb(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 encodeVarintEtherpb(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 *Error) Size() (n int) {
	var l int
	_ = l
	if m.Errcode != 0 {
		n += 1 + sovEtherpb(uint64(m.Errcode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovEtherpb(uint64(l))
	}
	return n
}

func (m *RequestHeader) Size() (n int) {
	var l int
	_ = l
	if m.ClusterId != 0 {
		n += 1 + sovEtherpb(uint64(m.ClusterId))
	}
	if m.WorkerId != 0 {
		n += 1 + sovEtherpb(uint64(m.WorkerId))
	}
	return n
}

func (m *ResponseHeader) Size() (n int) {
	var l int
	_ = l
	if m.ClusterId != 0 {
		n += 1 + sovEtherpb(uint64(m.ClusterId))
	}
	if m.WorkerId != 0 {
		n += 1 + sovEtherpb(uint64(m.WorkerId))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	return n
}

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

func (m *WorkerHeartbeatResponse) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if len(m.NewJobs) > 0 {
		for _, e := range m.NewJobs {
			l = e.Size()
			n += 1 + l + sovEtherpb(uint64(l))
		}
	}
	if len(m.ObsoleteJobIds) > 0 {
		l = 0
		for _, e := range m.ObsoleteJobIds {
			l += sovEtherpb(uint64(e))
		}
		n += 1 + sovEtherpb(uint64(l)) + l
	}
	return n
}

func (m *RegisterWorkerRequest) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if m.Worker != nil {
		l = m.Worker.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	return n
}

func (m *RegisterWorkerResponse) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	return n
}

func (m *RenewJobRequest) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if len(m.JobIds) > 0 {
		l = 0
		for _, e := range m.JobIds {
			l += sovEtherpb(uint64(e))
		}
		n += 1 + sovEtherpb(uint64(l)) + l
	}
	if m.Lease != 0 {
		n += 1 + sovEtherpb(uint64(m.Lease))
	}
	return n
}

func (m *RenewJobResponse) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if len(m.ExpiredJobs) > 0 {
		l = 0
		for _, e := range m.ExpiredJobs {
			l += sovEtherpb(uint64(e))
		}
		n += 1 + sovEtherpb(uint64(l)) + l
	}
	if len(m.ErrorJobs) > 0 {
		l = 0
		for _, e := range m.ErrorJobs {
			l += sovEtherpb(uint64(e))
		}
		n += 1 + sovEtherpb(uint64(l)) + l
	}
	return n
}

func (m *GetClusterInfoRequest) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *GetClusterInfoResponse) Size() (n int) {
	var l int
	_ = l
	if m.ClusterId != 0 {
		n += 1 + sovEtherpb(uint64(m.ClusterId))
	}
	l = len(m.StorageRootPath)
	if l > 0 {
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if m.Leader != nil {
		l = m.Leader.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if len(m.Members) > 0 {
		for _, e := range m.Members {
			l = e.Size()
			n += 1 + l + sovEtherpb(uint64(l))
		}
	}
	return n
}

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

func (m *CreateFenceResponse) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if m.FenceId != 0 {
		n += 1 + sovEtherpb(uint64(m.FenceId))
	}
	return n
}

func (m *WaitOnFenceRequest) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if m.FenceId != 0 {
		n += 1 + sovEtherpb(uint64(m.FenceId))
	}
	if m.JobId != 0 {
		n += 1 + sovEtherpb(uint64(m.JobId))
	}
	if m.Topic != nil {
		l = m.Topic.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if len(m.Partitions) > 0 {
		l = 0
		for _, e := range m.Partitions {
			l += sovEtherpb(uint64(e))
		}
		n += 1 + sovEtherpb(uint64(l)) + l
	}
	return n
}

func (m *WaitOnFenceResponse) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if m.IsSynced {
		n += 2
	}
	return n
}

func (m *Member) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovEtherpb(uint64(l))
	}
	if m.MemberId != 0 {
		n += 1 + sovEtherpb(uint64(m.MemberId))
	}
	if len(m.PeerUrls) > 0 {
		for _, s := range m.PeerUrls {
			l = len(s)
			n += 1 + l + sovEtherpb(uint64(l))
		}
	}
	if len(m.ClientUrls) > 0 {
		for _, s := range m.ClientUrls {
			l = len(s)
			n += 1 + l + sovEtherpb(uint64(l))
		}
	}
	return n
}

func sovEtherpb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozEtherpb(x uint64) (n int) {
	return sovEtherpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Error) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEtherpb
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errcode", wireType)
			}
			m.Errcode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEtherpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errcode |= (ErrorCode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowEtherpb
				}
				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 ErrInvalidLengthEtherpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEtherpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEtherpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WaitOnFenceRequest) 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 ErrIntOverflowEtherpb
			}
			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: WaitOnFenceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WaitOnFenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEtherpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEtherpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &RequestHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FenceId", wireType)
			}
			m.FenceId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEtherpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FenceId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType)
			}
			m.JobId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEtherpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.JobId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowEtherpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEtherpb
			}
			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 5:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEtherpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int32(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Partitions = append(m.Partitions, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEtherpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEtherpb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEtherpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Partitions = append(m.Partitions, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Partitions", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEtherpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEtherpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEtherpb(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, ErrIntOverflowEtherpb
			}
			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, ErrIntOverflowEtherpb
				}
				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, ErrIntOverflowEtherpb
				}
				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, ErrInvalidLengthEtherpb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowEtherpb
					}
					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 := skipEtherpb(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 (
	ErrInvalidLengthEtherpb = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEtherpb   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("etherpb.proto", fileDescriptorEtherpb) }

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