// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: base/types/gfsptask/task.proto

package gfsptask

import (
	fmt "fmt"
	gfsperrors "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsperrors"
	types2 "github.com/bnb-chain/greenfield/x/sp/types"
	types "github.com/bnb-chain/greenfield/x/storage/types"
	types1 "github.com/bnb-chain/greenfield/x/virtualgroup/types"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type GfSpTask struct {
	Address      string                `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	CreateTime   int64                 `protobuf:"varint,2,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	UpdateTime   int64                 `protobuf:"varint,3,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
	Timeout      int64                 `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
	TaskPriority int32                 `protobuf:"varint,5,opt,name=task_priority,json=taskPriority,proto3" json:"task_priority,omitempty"`
	Retry        int64                 `protobuf:"varint,6,opt,name=retry,proto3" json:"retry,omitempty"`
	MaxRetry     int64                 `protobuf:"varint,7,opt,name=max_retry,json=maxRetry,proto3" json:"max_retry,omitempty"`
	UserAddress  string                `protobuf:"bytes,8,opt,name=user_address,json=userAddress,proto3" json:"user_address,omitempty"`
	Logs         string                `protobuf:"bytes,9,opt,name=logs,proto3" json:"logs,omitempty"`
	Err          *gfsperrors.GfSpError `protobuf:"bytes,10,opt,name=err,proto3" json:"err,omitempty"`
}

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

var xxx_messageInfo_GfSpTask proto.InternalMessageInfo

func (m *GfSpTask) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

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

func (m *GfSpTask) GetUpdateTime() int64 {
	if m != nil {
		return m.UpdateTime
	}
	return 0
}

func (m *GfSpTask) GetTimeout() int64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

func (m *GfSpTask) GetTaskPriority() int32 {
	if m != nil {
		return m.TaskPriority
	}
	return 0
}

func (m *GfSpTask) GetRetry() int64 {
	if m != nil {
		return m.Retry
	}
	return 0
}

func (m *GfSpTask) GetMaxRetry() int64 {
	if m != nil {
		return m.MaxRetry
	}
	return 0
}

func (m *GfSpTask) GetUserAddress() string {
	if m != nil {
		return m.UserAddress
	}
	return ""
}

func (m *GfSpTask) GetLogs() string {
	if m != nil {
		return m.Logs
	}
	return ""
}

func (m *GfSpTask) GetErr() *gfsperrors.GfSpError {
	if m != nil {
		return m.Err
	}
	return nil
}

type GfSpCreateBucketApprovalTask struct {
	Task             *GfSpTask              `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	CreateBucketInfo *types.MsgCreateBucket `protobuf:"bytes,2,opt,name=create_bucket_info,json=createBucketInfo,proto3" json:"create_bucket_info,omitempty"`
	Fingerprint      []byte                 `protobuf:"bytes,3,opt,name=fingerprint,proto3" json:"fingerprint,omitempty"`
}

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

var xxx_messageInfo_GfSpCreateBucketApprovalTask proto.InternalMessageInfo

func (m *GfSpCreateBucketApprovalTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpCreateBucketApprovalTask) GetCreateBucketInfo() *types.MsgCreateBucket {
	if m != nil {
		return m.CreateBucketInfo
	}
	return nil
}

func (m *GfSpCreateBucketApprovalTask) GetFingerprint() []byte {
	if m != nil {
		return m.Fingerprint
	}
	return nil
}

type GfSpMigrateBucketApprovalTask struct {
	Task              *GfSpTask               `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	MigrateBucketInfo *types.MsgMigrateBucket `protobuf:"bytes,2,opt,name=migrate_bucket_info,json=migrateBucketInfo,proto3" json:"migrate_bucket_info,omitempty"`
}

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

var xxx_messageInfo_GfSpMigrateBucketApprovalTask proto.InternalMessageInfo

func (m *GfSpMigrateBucketApprovalTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpMigrateBucketApprovalTask) GetMigrateBucketInfo() *types.MsgMigrateBucket {
	if m != nil {
		return m.MigrateBucketInfo
	}
	return nil
}

type GfSpCreateObjectApprovalTask struct {
	Task             *GfSpTask              `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	CreateObjectInfo *types.MsgCreateObject `protobuf:"bytes,2,opt,name=create_object_info,json=createObjectInfo,proto3" json:"create_object_info,omitempty"`
	Fingerprint      []byte                 `protobuf:"bytes,3,opt,name=fingerprint,proto3" json:"fingerprint,omitempty"`
}

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

var xxx_messageInfo_GfSpCreateObjectApprovalTask proto.InternalMessageInfo

func (m *GfSpCreateObjectApprovalTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpCreateObjectApprovalTask) GetCreateObjectInfo() *types.MsgCreateObject {
	if m != nil {
		return m.CreateObjectInfo
	}
	return nil
}

func (m *GfSpCreateObjectApprovalTask) GetFingerprint() []byte {
	if m != nil {
		return m.Fingerprint
	}
	return nil
}

type GfSpDelegateCreateObjectApprovalTask struct {
	Task                 *GfSpTask                      `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	DelegateCreateObject *types.MsgDelegateCreateObject `protobuf:"bytes,2,opt,name=delegate_create_object,json=delegateCreateObject,proto3" json:"delegate_create_object,omitempty"`
	Fingerprint          []byte                         `protobuf:"bytes,3,opt,name=fingerprint,proto3" json:"fingerprint,omitempty"`
}

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

var xxx_messageInfo_GfSpDelegateCreateObjectApprovalTask proto.InternalMessageInfo

func (m *GfSpDelegateCreateObjectApprovalTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpDelegateCreateObjectApprovalTask) GetDelegateCreateObject() *types.MsgDelegateCreateObject {
	if m != nil {
		return m.DelegateCreateObject
	}
	return nil
}

func (m *GfSpDelegateCreateObjectApprovalTask) GetFingerprint() []byte {
	if m != nil {
		return m.Fingerprint
	}
	return nil
}

type GfSpReplicatePieceApprovalTask struct {
	Task                      *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo                *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams             *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	AskSpOperatorAddress      string            `protobuf:"bytes,4,opt,name=ask_sp_operator_address,json=askSpOperatorAddress,proto3" json:"ask_sp_operator_address,omitempty"`
	AskSignature              []byte            `protobuf:"bytes,5,opt,name=ask_signature,json=askSignature,proto3" json:"ask_signature,omitempty"`
	ApprovedSpEndpoint        string            `protobuf:"bytes,6,opt,name=approved_sp_endpoint,json=approvedSpEndpoint,proto3" json:"approved_sp_endpoint,omitempty"`
	ApprovedSpOperatorAddress string            `protobuf:"bytes,7,opt,name=approved_sp_operator_address,json=approvedSpOperatorAddress,proto3" json:"approved_sp_operator_address,omitempty"`
	ApprovedSignature         []byte            `protobuf:"bytes,8,opt,name=approved_signature,json=approvedSignature,proto3" json:"approved_signature,omitempty"`
	ApprovedSpApprovalAddress string            `protobuf:"bytes,9,opt,name=approved_sp_approval_address,json=approvedSpApprovalAddress,proto3" json:"approved_sp_approval_address,omitempty"`
	ExpiredHeight             uint64            `protobuf:"varint,10,opt,name=expired_height,json=expiredHeight,proto3" json:"expired_height,omitempty"`
}

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

var xxx_messageInfo_GfSpReplicatePieceApprovalTask proto.InternalMessageInfo

func (m *GfSpReplicatePieceApprovalTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpReplicatePieceApprovalTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpReplicatePieceApprovalTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpReplicatePieceApprovalTask) GetAskSpOperatorAddress() string {
	if m != nil {
		return m.AskSpOperatorAddress
	}
	return ""
}

func (m *GfSpReplicatePieceApprovalTask) GetAskSignature() []byte {
	if m != nil {
		return m.AskSignature
	}
	return nil
}

func (m *GfSpReplicatePieceApprovalTask) GetApprovedSpEndpoint() string {
	if m != nil {
		return m.ApprovedSpEndpoint
	}
	return ""
}

func (m *GfSpReplicatePieceApprovalTask) GetApprovedSpOperatorAddress() string {
	if m != nil {
		return m.ApprovedSpOperatorAddress
	}
	return ""
}

func (m *GfSpReplicatePieceApprovalTask) GetApprovedSignature() []byte {
	if m != nil {
		return m.ApprovedSignature
	}
	return nil
}

func (m *GfSpReplicatePieceApprovalTask) GetApprovedSpApprovalAddress() string {
	if m != nil {
		return m.ApprovedSpApprovalAddress
	}
	return ""
}

func (m *GfSpReplicatePieceApprovalTask) GetExpiredHeight() uint64 {
	if m != nil {
		return m.ExpiredHeight
	}
	return 0
}

type GfSpUploadObjectTask struct {
	Task                 *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	VirtualGroupFamilyId uint32            `protobuf:"varint,2,opt,name=virtual_group_family_id,json=virtualGroupFamilyId,proto3" json:"virtual_group_family_id,omitempty"`
	ObjectInfo           *types.ObjectInfo `protobuf:"bytes,3,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams        *types.Params     `protobuf:"bytes,4,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	IsAgentUpload        bool              `protobuf:"varint,5,opt,name=is_agent_upload,json=isAgentUpload,proto3" json:"is_agent_upload,omitempty"`
}

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

var xxx_messageInfo_GfSpUploadObjectTask proto.InternalMessageInfo

func (m *GfSpUploadObjectTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpUploadObjectTask) GetVirtualGroupFamilyId() uint32 {
	if m != nil {
		return m.VirtualGroupFamilyId
	}
	return 0
}

func (m *GfSpUploadObjectTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpUploadObjectTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpUploadObjectTask) GetIsAgentUpload() bool {
	if m != nil {
		return m.IsAgentUpload
	}
	return false
}

type GfSpResumableUploadObjectTask struct {
	Task                 *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo           *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams        *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	Offset               uint64            `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Length               uint64            `protobuf:"varint,5,opt,name=length,proto3" json:"length,omitempty"`
	Completed            bool              `protobuf:"varint,6,opt,name=completed,proto3" json:"completed,omitempty"`
	VirtualGroupFamilyId uint32            `protobuf:"varint,7,opt,name=virtual_group_family_id,json=virtualGroupFamilyId,proto3" json:"virtual_group_family_id,omitempty"`
	IsAgentUpload        bool              `protobuf:"varint,8,opt,name=is_agent_upload,json=isAgentUpload,proto3" json:"is_agent_upload,omitempty"`
}

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

var xxx_messageInfo_GfSpResumableUploadObjectTask proto.InternalMessageInfo

func (m *GfSpResumableUploadObjectTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpResumableUploadObjectTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpResumableUploadObjectTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpResumableUploadObjectTask) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *GfSpResumableUploadObjectTask) GetLength() uint64 {
	if m != nil {
		return m.Length
	}
	return 0
}

func (m *GfSpResumableUploadObjectTask) GetCompleted() bool {
	if m != nil {
		return m.Completed
	}
	return false
}

func (m *GfSpResumableUploadObjectTask) GetVirtualGroupFamilyId() uint32 {
	if m != nil {
		return m.VirtualGroupFamilyId
	}
	return 0
}

func (m *GfSpResumableUploadObjectTask) GetIsAgentUpload() bool {
	if m != nil {
		return m.IsAgentUpload
	}
	return false
}

type GfSpReplicatePieceTask struct {
	Task                 *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo           *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams        *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	SecondaryAddresses   []string          `protobuf:"bytes,4,rep,name=secondary_addresses,json=secondaryAddresses,proto3" json:"secondary_addresses,omitempty"`
	SecondarySignatures  [][]byte          `protobuf:"bytes,5,rep,name=secondary_signatures,json=secondarySignatures,proto3" json:"secondary_signatures,omitempty"`
	Sealed               bool              `protobuf:"varint,6,opt,name=sealed,proto3" json:"sealed,omitempty"`
	GlobalVirtualGroupId uint32            `protobuf:"varint,7,opt,name=global_virtual_group_id,json=globalVirtualGroupId,proto3" json:"global_virtual_group_id,omitempty"`
	SecondaryEndpoints   []string          `protobuf:"bytes,8,rep,name=secondary_endpoints,json=secondaryEndpoints,proto3" json:"secondary_endpoints,omitempty"`
	NotAvailableSpIdx    int32             `protobuf:"varint,9,opt,name=not_available_sp_idx,json=notAvailableSpIdx,proto3" json:"not_available_sp_idx,omitempty"`
	IsAgentUploadTask    bool              `protobuf:"varint,10,opt,name=is_agent_upload_task,json=isAgentUploadTask,proto3" json:"is_agent_upload_task,omitempty"`
}

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

var xxx_messageInfo_GfSpReplicatePieceTask proto.InternalMessageInfo

func (m *GfSpReplicatePieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpReplicatePieceTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpReplicatePieceTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpReplicatePieceTask) GetSecondaryAddresses() []string {
	if m != nil {
		return m.SecondaryAddresses
	}
	return nil
}

func (m *GfSpReplicatePieceTask) GetSecondarySignatures() [][]byte {
	if m != nil {
		return m.SecondarySignatures
	}
	return nil
}

func (m *GfSpReplicatePieceTask) GetSealed() bool {
	if m != nil {
		return m.Sealed
	}
	return false
}

func (m *GfSpReplicatePieceTask) GetGlobalVirtualGroupId() uint32 {
	if m != nil {
		return m.GlobalVirtualGroupId
	}
	return 0
}

func (m *GfSpReplicatePieceTask) GetSecondaryEndpoints() []string {
	if m != nil {
		return m.SecondaryEndpoints
	}
	return nil
}

func (m *GfSpReplicatePieceTask) GetNotAvailableSpIdx() int32 {
	if m != nil {
		return m.NotAvailableSpIdx
	}
	return 0
}

func (m *GfSpReplicatePieceTask) GetIsAgentUploadTask() bool {
	if m != nil {
		return m.IsAgentUploadTask
	}
	return false
}

type GfSpRecoverPieceTask struct {
	Task          *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo    *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	SegmentIdx    uint32            `protobuf:"varint,4,opt,name=segment_idx,json=segmentIdx,proto3" json:"segment_idx,omitempty"`
	EcIdx         int32             `protobuf:"varint,5,opt,name=ec_idx,json=ecIdx,proto3" json:"ec_idx,omitempty"`
	PieceSize     uint64            `protobuf:"varint,6,opt,name=piece_size,json=pieceSize,proto3" json:"piece_size,omitempty"`
	Signature     []byte            `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
	Recovered     bool              `protobuf:"varint,8,opt,name=recovered,proto3" json:"recovered,omitempty"`
	BySuccessorSp bool              `protobuf:"varint,9,opt,name=by_successor_sp,json=bySuccessorSp,proto3" json:"by_successor_sp,omitempty"`
	GvgId         uint32            `protobuf:"varint,10,opt,name=gvg_id,json=gvgId,proto3" json:"gvg_id,omitempty"`
}

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

var xxx_messageInfo_GfSpRecoverPieceTask proto.InternalMessageInfo

func (m *GfSpRecoverPieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpRecoverPieceTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpRecoverPieceTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpRecoverPieceTask) GetSegmentIdx() uint32 {
	if m != nil {
		return m.SegmentIdx
	}
	return 0
}

func (m *GfSpRecoverPieceTask) GetEcIdx() int32 {
	if m != nil {
		return m.EcIdx
	}
	return 0
}

func (m *GfSpRecoverPieceTask) GetPieceSize() uint64 {
	if m != nil {
		return m.PieceSize
	}
	return 0
}

func (m *GfSpRecoverPieceTask) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *GfSpRecoverPieceTask) GetRecovered() bool {
	if m != nil {
		return m.Recovered
	}
	return false
}

func (m *GfSpRecoverPieceTask) GetBySuccessorSp() bool {
	if m != nil {
		return m.BySuccessorSp
	}
	return false
}

func (m *GfSpRecoverPieceTask) GetGvgId() uint32 {
	if m != nil {
		return m.GvgId
	}
	return 0
}

type GfSpReceivePieceTask struct {
	Task                 *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo           *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams        *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	SegmentIdx           uint32            `protobuf:"varint,4,opt,name=segment_idx,json=segmentIdx,proto3" json:"segment_idx,omitempty"`
	RedundancyIdx        int32             `protobuf:"varint,5,opt,name=redundancy_idx,json=redundancyIdx,proto3" json:"redundancy_idx,omitempty"`
	PieceSize            int64             `protobuf:"varint,6,opt,name=piece_size,json=pieceSize,proto3" json:"piece_size,omitempty"`
	PieceChecksum        []byte            `protobuf:"bytes,7,opt,name=piece_checksum,json=pieceChecksum,proto3" json:"piece_checksum,omitempty"`
	Signature            []byte            `protobuf:"bytes,8,opt,name=signature,proto3" json:"signature,omitempty"`
	Sealed               bool              `protobuf:"varint,9,opt,name=sealed,proto3" json:"sealed,omitempty"`
	Finished             bool              `protobuf:"varint,10,opt,name=finished,proto3" json:"finished,omitempty"`
	GlobalVirtualGroupId uint32            `protobuf:"varint,11,opt,name=global_virtual_group_id,json=globalVirtualGroupId,proto3" json:"global_virtual_group_id,omitempty"`
	BucketMigration      bool              `protobuf:"varint,12,opt,name=bucket_migration,json=bucketMigration,proto3" json:"bucket_migration,omitempty"`
	IsAgentUploadTask    bool              `protobuf:"varint,13,opt,name=is_agent_upload_task,json=isAgentUploadTask,proto3" json:"is_agent_upload_task,omitempty"`
}

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

var xxx_messageInfo_GfSpReceivePieceTask proto.InternalMessageInfo

func (m *GfSpReceivePieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpReceivePieceTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpReceivePieceTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpReceivePieceTask) GetSegmentIdx() uint32 {
	if m != nil {
		return m.SegmentIdx
	}
	return 0
}

func (m *GfSpReceivePieceTask) GetRedundancyIdx() int32 {
	if m != nil {
		return m.RedundancyIdx
	}
	return 0
}

func (m *GfSpReceivePieceTask) GetPieceSize() int64 {
	if m != nil {
		return m.PieceSize
	}
	return 0
}

func (m *GfSpReceivePieceTask) GetPieceChecksum() []byte {
	if m != nil {
		return m.PieceChecksum
	}
	return nil
}

func (m *GfSpReceivePieceTask) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *GfSpReceivePieceTask) GetSealed() bool {
	if m != nil {
		return m.Sealed
	}
	return false
}

func (m *GfSpReceivePieceTask) GetFinished() bool {
	if m != nil {
		return m.Finished
	}
	return false
}

func (m *GfSpReceivePieceTask) GetGlobalVirtualGroupId() uint32 {
	if m != nil {
		return m.GlobalVirtualGroupId
	}
	return 0
}

func (m *GfSpReceivePieceTask) GetBucketMigration() bool {
	if m != nil {
		return m.BucketMigration
	}
	return false
}

func (m *GfSpReceivePieceTask) GetIsAgentUploadTask() bool {
	if m != nil {
		return m.IsAgentUploadTask
	}
	return false
}

type GfSpSealObjectTask struct {
	Task                 *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo           *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams        *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	SecondaryAddresses   []string          `protobuf:"bytes,4,rep,name=secondary_addresses,json=secondaryAddresses,proto3" json:"secondary_addresses,omitempty"`
	SecondarySignatures  [][]byte          `protobuf:"bytes,5,rep,name=secondary_signatures,json=secondarySignatures,proto3" json:"secondary_signatures,omitempty"`
	GlobalVirtualGroupId uint32            `protobuf:"varint,6,opt,name=global_virtual_group_id,json=globalVirtualGroupId,proto3" json:"global_virtual_group_id,omitempty"`
	SecondaryEndpoints   []string          `protobuf:"bytes,7,rep,name=secondary_endpoints,json=secondaryEndpoints,proto3" json:"secondary_endpoints,omitempty"`
	IsAgentUploadTask    bool              `protobuf:"varint,8,opt,name=is_agent_upload_task,json=isAgentUploadTask,proto3" json:"is_agent_upload_task,omitempty"`
}

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

var xxx_messageInfo_GfSpSealObjectTask proto.InternalMessageInfo

func (m *GfSpSealObjectTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpSealObjectTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpSealObjectTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpSealObjectTask) GetSecondaryAddresses() []string {
	if m != nil {
		return m.SecondaryAddresses
	}
	return nil
}

func (m *GfSpSealObjectTask) GetSecondarySignatures() [][]byte {
	if m != nil {
		return m.SecondarySignatures
	}
	return nil
}

func (m *GfSpSealObjectTask) GetGlobalVirtualGroupId() uint32 {
	if m != nil {
		return m.GlobalVirtualGroupId
	}
	return 0
}

func (m *GfSpSealObjectTask) GetSecondaryEndpoints() []string {
	if m != nil {
		return m.SecondaryEndpoints
	}
	return nil
}

func (m *GfSpSealObjectTask) GetIsAgentUploadTask() bool {
	if m != nil {
		return m.IsAgentUploadTask
	}
	return false
}

type GfSpDownloadObjectTask struct {
	Task          *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo    *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	BucketInfo    *types.BucketInfo `protobuf:"bytes,3,opt,name=bucket_info,json=bucketInfo,proto3" json:"bucket_info,omitempty"`
	StorageParams *types.Params     `protobuf:"bytes,4,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	Low           int64             `protobuf:"varint,5,opt,name=low,proto3" json:"low,omitempty"`
	High          int64             `protobuf:"varint,6,opt,name=high,proto3" json:"high,omitempty"`
}

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

var xxx_messageInfo_GfSpDownloadObjectTask proto.InternalMessageInfo

func (m *GfSpDownloadObjectTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpDownloadObjectTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpDownloadObjectTask) GetBucketInfo() *types.BucketInfo {
	if m != nil {
		return m.BucketInfo
	}
	return nil
}

func (m *GfSpDownloadObjectTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpDownloadObjectTask) GetLow() int64 {
	if m != nil {
		return m.Low
	}
	return 0
}

func (m *GfSpDownloadObjectTask) GetHigh() int64 {
	if m != nil {
		return m.High
	}
	return 0
}

type GfSpDownloadPieceTask struct {
	Task          *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo    *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	BucketInfo    *types.BucketInfo `protobuf:"bytes,3,opt,name=bucket_info,json=bucketInfo,proto3" json:"bucket_info,omitempty"`
	StorageParams *types.Params     `protobuf:"bytes,4,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	EnableCheck   bool              `protobuf:"varint,5,opt,name=enable_check,json=enableCheck,proto3" json:"enable_check,omitempty"`
	TotalSize     uint64            `protobuf:"varint,6,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
	PieceKey      string            `protobuf:"bytes,7,opt,name=piece_key,json=pieceKey,proto3" json:"piece_key,omitempty"`
	PieceOffset   uint64            `protobuf:"varint,8,opt,name=piece_offset,json=pieceOffset,proto3" json:"piece_offset,omitempty"`
	PieceLength   uint64            `protobuf:"varint,9,opt,name=piece_length,json=pieceLength,proto3" json:"piece_length,omitempty"`
}

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

var xxx_messageInfo_GfSpDownloadPieceTask proto.InternalMessageInfo

func (m *GfSpDownloadPieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpDownloadPieceTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpDownloadPieceTask) GetBucketInfo() *types.BucketInfo {
	if m != nil {
		return m.BucketInfo
	}
	return nil
}

func (m *GfSpDownloadPieceTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpDownloadPieceTask) GetEnableCheck() bool {
	if m != nil {
		return m.EnableCheck
	}
	return false
}

func (m *GfSpDownloadPieceTask) GetTotalSize() uint64 {
	if m != nil {
		return m.TotalSize
	}
	return 0
}

func (m *GfSpDownloadPieceTask) GetPieceKey() string {
	if m != nil {
		return m.PieceKey
	}
	return ""
}

func (m *GfSpDownloadPieceTask) GetPieceOffset() uint64 {
	if m != nil {
		return m.PieceOffset
	}
	return 0
}

func (m *GfSpDownloadPieceTask) GetPieceLength() uint64 {
	if m != nil {
		return m.PieceLength
	}
	return 0
}

type GfSpChallengePieceTask struct {
	Task          *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo    *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	BucketInfo    *types.BucketInfo `protobuf:"bytes,3,opt,name=bucket_info,json=bucketInfo,proto3" json:"bucket_info,omitempty"`
	StorageParams *types.Params     `protobuf:"bytes,4,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	SegmentIdx    uint32            `protobuf:"varint,5,opt,name=segment_idx,json=segmentIdx,proto3" json:"segment_idx,omitempty"`
	RedundancyIdx int32             `protobuf:"varint,6,opt,name=redundancy_idx,json=redundancyIdx,proto3" json:"redundancy_idx,omitempty"`
	IntegrityHash []byte            `protobuf:"bytes,7,opt,name=integrity_hash,json=integrityHash,proto3" json:"integrity_hash,omitempty"`
	PieceHash     [][]byte          `protobuf:"bytes,8,rep,name=piece_hash,json=pieceHash,proto3" json:"piece_hash,omitempty"`
	PieceDataSize int64             `protobuf:"varint,9,opt,name=piece_data_size,json=pieceDataSize,proto3" json:"piece_data_size,omitempty"`
}

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

var xxx_messageInfo_GfSpChallengePieceTask proto.InternalMessageInfo

func (m *GfSpChallengePieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpChallengePieceTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpChallengePieceTask) GetBucketInfo() *types.BucketInfo {
	if m != nil {
		return m.BucketInfo
	}
	return nil
}

func (m *GfSpChallengePieceTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpChallengePieceTask) GetSegmentIdx() uint32 {
	if m != nil {
		return m.SegmentIdx
	}
	return 0
}

func (m *GfSpChallengePieceTask) GetRedundancyIdx() int32 {
	if m != nil {
		return m.RedundancyIdx
	}
	return 0
}

func (m *GfSpChallengePieceTask) GetIntegrityHash() []byte {
	if m != nil {
		return m.IntegrityHash
	}
	return nil
}

func (m *GfSpChallengePieceTask) GetPieceHash() [][]byte {
	if m != nil {
		return m.PieceHash
	}
	return nil
}

func (m *GfSpChallengePieceTask) GetPieceDataSize() int64 {
	if m != nil {
		return m.PieceDataSize
	}
	return 0
}

type GfSpGCObjectTask struct {
	Task                *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	StartBlockNumber    uint64    `protobuf:"varint,2,opt,name=start_block_number,json=startBlockNumber,proto3" json:"start_block_number,omitempty"`
	EndBlockNumber      uint64    `protobuf:"varint,3,opt,name=end_block_number,json=endBlockNumber,proto3" json:"end_block_number,omitempty"`
	CurrentBlockNumber  uint64    `protobuf:"varint,4,opt,name=current_block_number,json=currentBlockNumber,proto3" json:"current_block_number,omitempty"`
	LastDeletedObjectId uint64    `protobuf:"varint,5,opt,name=last_deleted_object_id,json=lastDeletedObjectId,proto3" json:"last_deleted_object_id,omitempty"`
	Running             bool      `protobuf:"varint,6,opt,name=running,proto3" json:"running,omitempty"`
}

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

var xxx_messageInfo_GfSpGCObjectTask proto.InternalMessageInfo

func (m *GfSpGCObjectTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpGCObjectTask) GetStartBlockNumber() uint64 {
	if m != nil {
		return m.StartBlockNumber
	}
	return 0
}

func (m *GfSpGCObjectTask) GetEndBlockNumber() uint64 {
	if m != nil {
		return m.EndBlockNumber
	}
	return 0
}

func (m *GfSpGCObjectTask) GetCurrentBlockNumber() uint64 {
	if m != nil {
		return m.CurrentBlockNumber
	}
	return 0
}

func (m *GfSpGCObjectTask) GetLastDeletedObjectId() uint64 {
	if m != nil {
		return m.LastDeletedObjectId
	}
	return 0
}

func (m *GfSpGCObjectTask) GetRunning() bool {
	if m != nil {
		return m.Running
	}
	return false
}

type GfSpGCZombiePieceTask struct {
	Task          *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	Running       bool      `protobuf:"varint,2,opt,name=running,proto3" json:"running,omitempty"`
	StartObjectId uint64    `protobuf:"varint,3,opt,name=start_object_id,json=startObjectId,proto3" json:"start_object_id,omitempty"`
	EndObjectId   uint64    `protobuf:"varint,4,opt,name=end_object_id,json=endObjectId,proto3" json:"end_object_id,omitempty"`
	Finished      bool      `protobuf:"varint,5,opt,name=finished,proto3" json:"finished,omitempty"`
}

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

var xxx_messageInfo_GfSpGCZombiePieceTask proto.InternalMessageInfo

func (m *GfSpGCZombiePieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpGCZombiePieceTask) GetRunning() bool {
	if m != nil {
		return m.Running
	}
	return false
}

func (m *GfSpGCZombiePieceTask) GetStartObjectId() uint64 {
	if m != nil {
		return m.StartObjectId
	}
	return 0
}

func (m *GfSpGCZombiePieceTask) GetEndObjectId() uint64 {
	if m != nil {
		return m.EndObjectId
	}
	return 0
}

func (m *GfSpGCZombiePieceTask) GetFinished() bool {
	if m != nil {
		return m.Finished
	}
	return false
}

type GfSpGCStaleVersionObjectTask struct {
	Task              *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectId          uint64    `protobuf:"varint,2,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
	RedundancyIndex   int32     `protobuf:"varint,3,opt,name=redundancy_index,json=redundancyIndex,proto3" json:"redundancy_index,omitempty"`
	Version           int64     `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	IntegrityChecksum []byte    `protobuf:"bytes,5,opt,name=integrity_checksum,json=integrityChecksum,proto3" json:"integrity_checksum,omitempty"`
	PieceChecksumList [][]byte  `protobuf:"bytes,6,rep,name=piece_checksum_list,json=pieceChecksumList,proto3" json:"piece_checksum_list,omitempty"`
	ObjectSize        uint64    `protobuf:"varint,7,opt,name=object_size,json=objectSize,proto3" json:"object_size,omitempty"`
}

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

var xxx_messageInfo_GfSpGCStaleVersionObjectTask proto.InternalMessageInfo

func (m *GfSpGCStaleVersionObjectTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpGCStaleVersionObjectTask) GetObjectId() uint64 {
	if m != nil {
		return m.ObjectId
	}
	return 0
}

func (m *GfSpGCStaleVersionObjectTask) GetRedundancyIndex() int32 {
	if m != nil {
		return m.RedundancyIndex
	}
	return 0
}

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

func (m *GfSpGCStaleVersionObjectTask) GetIntegrityChecksum() []byte {
	if m != nil {
		return m.IntegrityChecksum
	}
	return nil
}

func (m *GfSpGCStaleVersionObjectTask) GetPieceChecksumList() [][]byte {
	if m != nil {
		return m.PieceChecksumList
	}
	return nil
}

func (m *GfSpGCStaleVersionObjectTask) GetObjectSize() uint64 {
	if m != nil {
		return m.ObjectSize
	}
	return 0
}

type GfSpGCMetaTask struct {
	Task        *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	CurrentIdx  uint64    `protobuf:"varint,2,opt,name=current_idx,json=currentIdx,proto3" json:"current_idx,omitempty"`
	DeleteCount uint64    `protobuf:"varint,3,opt,name=delete_count,json=deleteCount,proto3" json:"delete_count,omitempty"`
}

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

var xxx_messageInfo_GfSpGCMetaTask proto.InternalMessageInfo

func (m *GfSpGCMetaTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpGCMetaTask) GetCurrentIdx() uint64 {
	if m != nil {
		return m.CurrentIdx
	}
	return 0
}

func (m *GfSpGCMetaTask) GetDeleteCount() uint64 {
	if m != nil {
		return m.DeleteCount
	}
	return 0
}

type GfSpMigrateGVGTask struct {
	Task                 *GfSpTask                  `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	BucketId             uint64                     `protobuf:"varint,2,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"`
	SrcGvg               *types1.GlobalVirtualGroup `protobuf:"bytes,3,opt,name=src_gvg,json=srcGvg,proto3" json:"src_gvg,omitempty"`
	DestGvg              *types1.GlobalVirtualGroup `protobuf:"bytes,4,opt,name=dest_gvg,json=destGvg,proto3" json:"dest_gvg,omitempty"`
	RedundancyIdx        int32                      `protobuf:"varint,5,opt,name=redundancy_idx,json=redundancyIdx,proto3" json:"redundancy_idx,omitempty"`
	SrcSp                *types2.StorageProvider    `protobuf:"bytes,6,opt,name=src_sp,json=srcSp,proto3" json:"src_sp,omitempty"`
	LastMigratedObjectId uint64                     `protobuf:"varint,7,opt,name=last_migrated_object_id,json=lastMigratedObjectId,proto3" json:"last_migrated_object_id,omitempty"`
	Finished             bool                       `protobuf:"varint,8,opt,name=finished,proto3" json:"finished,omitempty"`
	ExpireTime           int64                      `protobuf:"varint,9,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	Signature            []byte                     `protobuf:"bytes,10,opt,name=signature,proto3" json:"signature,omitempty"`
	MigratedBytesSize    uint64                     `protobuf:"varint,11,opt,name=migrated_bytes_size,json=migratedBytesSize,proto3" json:"migrated_bytes_size,omitempty"`
}

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

var xxx_messageInfo_GfSpMigrateGVGTask proto.InternalMessageInfo

func (m *GfSpMigrateGVGTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpMigrateGVGTask) GetBucketId() uint64 {
	if m != nil {
		return m.BucketId
	}
	return 0
}

func (m *GfSpMigrateGVGTask) GetSrcGvg() *types1.GlobalVirtualGroup {
	if m != nil {
		return m.SrcGvg
	}
	return nil
}

func (m *GfSpMigrateGVGTask) GetDestGvg() *types1.GlobalVirtualGroup {
	if m != nil {
		return m.DestGvg
	}
	return nil
}

func (m *GfSpMigrateGVGTask) GetRedundancyIdx() int32 {
	if m != nil {
		return m.RedundancyIdx
	}
	return 0
}

func (m *GfSpMigrateGVGTask) GetSrcSp() *types2.StorageProvider {
	if m != nil {
		return m.SrcSp
	}
	return nil
}

func (m *GfSpMigrateGVGTask) GetLastMigratedObjectId() uint64 {
	if m != nil {
		return m.LastMigratedObjectId
	}
	return 0
}

func (m *GfSpMigrateGVGTask) GetFinished() bool {
	if m != nil {
		return m.Finished
	}
	return false
}

func (m *GfSpMigrateGVGTask) GetExpireTime() int64 {
	if m != nil {
		return m.ExpireTime
	}
	return 0
}

func (m *GfSpMigrateGVGTask) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *GfSpMigrateGVGTask) GetMigratedBytesSize() uint64 {
	if m != nil {
		return m.MigratedBytesSize
	}
	return 0
}

type GfSpMigratePieceTask struct {
	Task            *GfSpTask         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	ObjectInfo      *types.ObjectInfo `protobuf:"bytes,2,opt,name=object_info,json=objectInfo,proto3" json:"object_info,omitempty"`
	StorageParams   *types.Params     `protobuf:"bytes,3,opt,name=storage_params,json=storageParams,proto3" json:"storage_params,omitempty"`
	SrcSpEndpoint   string            `protobuf:"bytes,4,opt,name=src_sp_endpoint,json=srcSpEndpoint,proto3" json:"src_sp_endpoint,omitempty"`
	SegmentIdx      uint32            `protobuf:"varint,5,opt,name=segment_idx,json=segmentIdx,proto3" json:"segment_idx,omitempty"`
	RedundancyIdx   int32             `protobuf:"varint,6,opt,name=redundancy_idx,json=redundancyIdx,proto3" json:"redundancy_idx,omitempty"`
	IsBucketMigrate bool              `protobuf:"varint,7,opt,name=is_bucket_migrate,json=isBucketMigrate,proto3" json:"is_bucket_migrate,omitempty"`
}

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

var xxx_messageInfo_GfSpMigratePieceTask proto.InternalMessageInfo

func (m *GfSpMigratePieceTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpMigratePieceTask) GetObjectInfo() *types.ObjectInfo {
	if m != nil {
		return m.ObjectInfo
	}
	return nil
}

func (m *GfSpMigratePieceTask) GetStorageParams() *types.Params {
	if m != nil {
		return m.StorageParams
	}
	return nil
}

func (m *GfSpMigratePieceTask) GetSrcSpEndpoint() string {
	if m != nil {
		return m.SrcSpEndpoint
	}
	return ""
}

func (m *GfSpMigratePieceTask) GetSegmentIdx() uint32 {
	if m != nil {
		return m.SegmentIdx
	}
	return 0
}

func (m *GfSpMigratePieceTask) GetRedundancyIdx() int32 {
	if m != nil {
		return m.RedundancyIdx
	}
	return 0
}

func (m *GfSpMigratePieceTask) GetIsBucketMigrate() bool {
	if m != nil {
		return m.IsBucketMigrate
	}
	return false
}

type GfSpGCBucketMigrationTask struct {
	Task           *GfSpTask `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	BucketId       uint64    `protobuf:"varint,2,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"`
	LastGcObjectId uint64    `protobuf:"varint,3,opt,name=last_gc_object_id,json=lastGcObjectId,proto3" json:"last_gc_object_id,omitempty"`
	LastGcGvgId    uint64    `protobuf:"varint,4,opt,name=last_gc_gvg_id,json=lastGcGvgId,proto3" json:"last_gc_gvg_id,omitempty"`
	// whether the gc of bucket migration succeed
	Finished         bool   `protobuf:"varint,5,opt,name=finished,proto3" json:"finished,omitempty"`
	TotalGvgNum      uint64 `protobuf:"varint,6,opt,name=total_gvg_num,json=totalGvgNum,proto3" json:"total_gvg_num,omitempty"`
	GcFinishedGvgNum uint64 `protobuf:"varint,7,opt,name=gc_finished_gvg_num,json=gcFinishedGvgNum,proto3" json:"gc_finished_gvg_num,omitempty"`
}

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

var xxx_messageInfo_GfSpGCBucketMigrationTask proto.InternalMessageInfo

func (m *GfSpGCBucketMigrationTask) GetTask() *GfSpTask {
	if m != nil {
		return m.Task
	}
	return nil
}

func (m *GfSpGCBucketMigrationTask) GetBucketId() uint64 {
	if m != nil {
		return m.BucketId
	}
	return 0
}

func (m *GfSpGCBucketMigrationTask) GetLastGcObjectId() uint64 {
	if m != nil {
		return m.LastGcObjectId
	}
	return 0
}

func (m *GfSpGCBucketMigrationTask) GetLastGcGvgId() uint64 {
	if m != nil {
		return m.LastGcGvgId
	}
	return 0
}

func (m *GfSpGCBucketMigrationTask) GetFinished() bool {
	if m != nil {
		return m.Finished
	}
	return false
}

func (m *GfSpGCBucketMigrationTask) GetTotalGvgNum() uint64 {
	if m != nil {
		return m.TotalGvgNum
	}
	return 0
}

func (m *GfSpGCBucketMigrationTask) GetGcFinishedGvgNum() uint64 {
	if m != nil {
		return m.GcFinishedGvgNum
	}
	return 0
}

type GfSpBucketMigrationInfo struct {
	BucketId uint64 `protobuf:"varint,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"`
	// whether the migrate bucket succeed
	Finished bool `protobuf:"varint,2,opt,name=finished,proto3" json:"finished,omitempty"`
	// total migrated bytes
	MigratedBytesSize uint64                  `protobuf:"varint,3,opt,name=migrated_bytes_size,json=migratedBytesSize,proto3" json:"migrated_bytes_size,omitempty"`
	DestSp            *types2.StorageProvider `protobuf:"bytes,4,opt,name=dest_sp,json=destSp,proto3" json:"dest_sp,omitempty"`
	SrcSp             *types2.StorageProvider `protobuf:"bytes,5,opt,name=src_sp,json=srcSp,proto3" json:"src_sp,omitempty"`
	ExpireTime        int64                   `protobuf:"varint,6,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	Signature         []byte                  `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
}

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

var xxx_messageInfo_GfSpBucketMigrationInfo proto.InternalMessageInfo

func (m *GfSpBucketMigrationInfo) GetBucketId() uint64 {
	if m != nil {
		return m.BucketId
	}
	return 0
}

func (m *GfSpBucketMigrationInfo) GetFinished() bool {
	if m != nil {
		return m.Finished
	}
	return false
}

func (m *GfSpBucketMigrationInfo) GetMigratedBytesSize() uint64 {
	if m != nil {
		return m.MigratedBytesSize
	}
	return 0
}

func (m *GfSpBucketMigrationInfo) GetDestSp() *types2.StorageProvider {
	if m != nil {
		return m.DestSp
	}
	return nil
}

func (m *GfSpBucketMigrationInfo) GetSrcSp() *types2.StorageProvider {
	if m != nil {
		return m.SrcSp
	}
	return nil
}

func (m *GfSpBucketMigrationInfo) GetExpireTime() int64 {
	if m != nil {
		return m.ExpireTime
	}
	return 0
}

func (m *GfSpBucketMigrationInfo) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

type GfSpBucketQuotaInfo struct {
	BucketId   uint64 `protobuf:"varint,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"`
	Month      string `protobuf:"bytes,2,opt,name=month,proto3" json:"month,omitempty"`
	BucketName string `protobuf:"bytes,3,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"`
	// the consumed chargedQuota of this month
	ReadConsumedSize uint64 `protobuf:"varint,4,opt,name=read_consumed_size,json=readConsumedSize,proto3" json:"read_consumed_size,omitempty"`
	// the consumed free quota size of this month
	FreeQuotaConsumedSize uint64 `protobuf:"varint,5,opt,name=free_quota_consumed_size,json=freeQuotaConsumedSize,proto3" json:"free_quota_consumed_size,omitempty"`
	// the remained free quota
	FreeQuotaSize uint64 `protobuf:"varint,6,opt,name=free_quota_size,json=freeQuotaSize,proto3" json:"free_quota_size,omitempty"`
	// the greenfield chain bucket charged quota
	ChargedQuotaSize uint64 `protobuf:"varint,7,opt,name=charged_quota_size,json=chargedQuotaSize,proto3" json:"charged_quota_size,omitempty"`
	// used to check if the src sp has enough quota to execute bucket migration
	AllowMigrate bool `protobuf:"varint,8,opt,name=allow_migrate,json=allowMigrate,proto3" json:"allow_migrate,omitempty"`
	// the remained monthly free quota
	MonthlyFreeQuotaSize uint64 `protobuf:"varint,9,opt,name=monthly_free_quota_size,json=monthlyFreeQuotaSize,proto3" json:"monthly_free_quota_size,omitempty"`
	// the consumed monthly free quota size of this month
	MonthlyFreeQuotaConsumedSize uint64 `protobuf:"varint,10,opt,name=monthly_free_quota_consumed_size,json=monthlyFreeQuotaConsumedSize,proto3" json:"monthly_free_quota_consumed_size,omitempty"`
}

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

var xxx_messageInfo_GfSpBucketQuotaInfo proto.InternalMessageInfo

func (m *GfSpBucketQuotaInfo) GetBucketId() uint64 {
	if m != nil {
		return m.BucketId
	}
	return 0
}

func (m *GfSpBucketQuotaInfo) GetMonth() string {
	if m != nil {
		return m.Month
	}
	return ""
}

func (m *GfSpBucketQuotaInfo) GetBucketName() string {
	if m != nil {
		return m.BucketName
	}
	return ""
}

func (m *GfSpBucketQuotaInfo) GetReadConsumedSize() uint64 {
	if m != nil {
		return m.ReadConsumedSize
	}
	return 0
}

func (m *GfSpBucketQuotaInfo) GetFreeQuotaConsumedSize() uint64 {
	if m != nil {
		return m.FreeQuotaConsumedSize
	}
	return 0
}

func (m *GfSpBucketQuotaInfo) GetFreeQuotaSize() uint64 {
	if m != nil {
		return m.FreeQuotaSize
	}
	return 0
}

func (m *GfSpBucketQuotaInfo) GetChargedQuotaSize() uint64 {
	if m != nil {
		return m.ChargedQuotaSize
	}
	return 0
}

func (m *GfSpBucketQuotaInfo) GetAllowMigrate() bool {
	if m != nil {
		return m.AllowMigrate
	}
	return false
}

func (m *GfSpBucketQuotaInfo) GetMonthlyFreeQuotaSize() uint64 {
	if m != nil {
		return m.MonthlyFreeQuotaSize
	}
	return 0
}

func (m *GfSpBucketQuotaInfo) GetMonthlyFreeQuotaConsumedSize() uint64 {
	if m != nil {
		return m.MonthlyFreeQuotaConsumedSize
	}
	return 0
}

func init() {
	proto.RegisterType((*GfSpTask)(nil), "base.types.gfsptask.GfSpTask")
	proto.RegisterType((*GfSpCreateBucketApprovalTask)(nil), "base.types.gfsptask.GfSpCreateBucketApprovalTask")
	proto.RegisterType((*GfSpMigrateBucketApprovalTask)(nil), "base.types.gfsptask.GfSpMigrateBucketApprovalTask")
	proto.RegisterType((*GfSpCreateObjectApprovalTask)(nil), "base.types.gfsptask.GfSpCreateObjectApprovalTask")
	proto.RegisterType((*GfSpDelegateCreateObjectApprovalTask)(nil), "base.types.gfsptask.GfSpDelegateCreateObjectApprovalTask")
	proto.RegisterType((*GfSpReplicatePieceApprovalTask)(nil), "base.types.gfsptask.GfSpReplicatePieceApprovalTask")
	proto.RegisterType((*GfSpUploadObjectTask)(nil), "base.types.gfsptask.GfSpUploadObjectTask")
	proto.RegisterType((*GfSpResumableUploadObjectTask)(nil), "base.types.gfsptask.GfSpResumableUploadObjectTask")
	proto.RegisterType((*GfSpReplicatePieceTask)(nil), "base.types.gfsptask.GfSpReplicatePieceTask")
	proto.RegisterType((*GfSpRecoverPieceTask)(nil), "base.types.gfsptask.GfSpRecoverPieceTask")
	proto.RegisterType((*GfSpReceivePieceTask)(nil), "base.types.gfsptask.GfSpReceivePieceTask")
	proto.RegisterType((*GfSpSealObjectTask)(nil), "base.types.gfsptask.GfSpSealObjectTask")
	proto.RegisterType((*GfSpDownloadObjectTask)(nil), "base.types.gfsptask.GfSpDownloadObjectTask")
	proto.RegisterType((*GfSpDownloadPieceTask)(nil), "base.types.gfsptask.GfSpDownloadPieceTask")
	proto.RegisterType((*GfSpChallengePieceTask)(nil), "base.types.gfsptask.GfSpChallengePieceTask")
	proto.RegisterType((*GfSpGCObjectTask)(nil), "base.types.gfsptask.GfSpGCObjectTask")
	proto.RegisterType((*GfSpGCZombiePieceTask)(nil), "base.types.gfsptask.GfSpGCZombiePieceTask")
	proto.RegisterType((*GfSpGCStaleVersionObjectTask)(nil), "base.types.gfsptask.GfSpGCStaleVersionObjectTask")
	proto.RegisterType((*GfSpGCMetaTask)(nil), "base.types.gfsptask.GfSpGCMetaTask")
	proto.RegisterType((*GfSpMigrateGVGTask)(nil), "base.types.gfsptask.GfSpMigrateGVGTask")
	proto.RegisterType((*GfSpMigratePieceTask)(nil), "base.types.gfsptask.GfSpMigratePieceTask")
	proto.RegisterType((*GfSpGCBucketMigrationTask)(nil), "base.types.gfsptask.GfSpGCBucketMigrationTask")
	proto.RegisterType((*GfSpBucketMigrationInfo)(nil), "base.types.gfsptask.GfSpBucketMigrationInfo")
	proto.RegisterType((*GfSpBucketQuotaInfo)(nil), "base.types.gfsptask.GfSpBucketQuotaInfo")
}

func init() { proto.RegisterFile("base/types/gfsptask/task.proto", fileDescriptor_0d22df708e229306) }

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

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

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

func (m *GfSpTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Err != nil {
		{
			size, err := m.Err.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if len(m.Logs) > 0 {
		i -= len(m.Logs)
		copy(dAtA[i:], m.Logs)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Logs)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.UserAddress) > 0 {
		i -= len(m.UserAddress)
		copy(dAtA[i:], m.UserAddress)
		i = encodeVarintTask(dAtA, i, uint64(len(m.UserAddress)))
		i--
		dAtA[i] = 0x42
	}
	if m.MaxRetry != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MaxRetry))
		i--
		dAtA[i] = 0x38
	}
	if m.Retry != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Retry))
		i--
		dAtA[i] = 0x30
	}
	if m.TaskPriority != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.TaskPriority))
		i--
		dAtA[i] = 0x28
	}
	if m.Timeout != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x20
	}
	if m.UpdateTime != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.UpdateTime))
		i--
		dAtA[i] = 0x18
	}
	if m.CreateTime != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CreateTime))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpCreateBucketApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fingerprint) > 0 {
		i -= len(m.Fingerprint)
		copy(dAtA[i:], m.Fingerprint)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Fingerprint)))
		i--
		dAtA[i] = 0x1a
	}
	if m.CreateBucketInfo != nil {
		{
			size, err := m.CreateBucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpMigrateBucketApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MigrateBucketInfo != nil {
		{
			size, err := m.MigrateBucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpCreateObjectApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fingerprint) > 0 {
		i -= len(m.Fingerprint)
		copy(dAtA[i:], m.Fingerprint)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Fingerprint)))
		i--
		dAtA[i] = 0x1a
	}
	if m.CreateObjectInfo != nil {
		{
			size, err := m.CreateObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpDelegateCreateObjectApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fingerprint) > 0 {
		i -= len(m.Fingerprint)
		copy(dAtA[i:], m.Fingerprint)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Fingerprint)))
		i--
		dAtA[i] = 0x1a
	}
	if m.DelegateCreateObject != nil {
		{
			size, err := m.DelegateCreateObject.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpReplicatePieceApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExpiredHeight != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ExpiredHeight))
		i--
		dAtA[i] = 0x50
	}
	if len(m.ApprovedSpApprovalAddress) > 0 {
		i -= len(m.ApprovedSpApprovalAddress)
		copy(dAtA[i:], m.ApprovedSpApprovalAddress)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ApprovedSpApprovalAddress)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.ApprovedSignature) > 0 {
		i -= len(m.ApprovedSignature)
		copy(dAtA[i:], m.ApprovedSignature)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ApprovedSignature)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.ApprovedSpOperatorAddress) > 0 {
		i -= len(m.ApprovedSpOperatorAddress)
		copy(dAtA[i:], m.ApprovedSpOperatorAddress)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ApprovedSpOperatorAddress)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ApprovedSpEndpoint) > 0 {
		i -= len(m.ApprovedSpEndpoint)
		copy(dAtA[i:], m.ApprovedSpEndpoint)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ApprovedSpEndpoint)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.AskSignature) > 0 {
		i -= len(m.AskSignature)
		copy(dAtA[i:], m.AskSignature)
		i = encodeVarintTask(dAtA, i, uint64(len(m.AskSignature)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.AskSpOperatorAddress) > 0 {
		i -= len(m.AskSpOperatorAddress)
		copy(dAtA[i:], m.AskSpOperatorAddress)
		i = encodeVarintTask(dAtA, i, uint64(len(m.AskSpOperatorAddress)))
		i--
		dAtA[i] = 0x22
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpUploadObjectTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsAgentUpload {
		i--
		if m.IsAgentUpload {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.VirtualGroupFamilyId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.VirtualGroupFamilyId))
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpResumableUploadObjectTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsAgentUpload {
		i--
		if m.IsAgentUpload {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.VirtualGroupFamilyId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.VirtualGroupFamilyId))
		i--
		dAtA[i] = 0x38
	}
	if m.Completed {
		i--
		if m.Completed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Length != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Length))
		i--
		dAtA[i] = 0x28
	}
	if m.Offset != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x20
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpReplicatePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsAgentUploadTask {
		i--
		if m.IsAgentUploadTask {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.NotAvailableSpIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.NotAvailableSpIdx))
		i--
		dAtA[i] = 0x48
	}
	if len(m.SecondaryEndpoints) > 0 {
		for iNdEx := len(m.SecondaryEndpoints) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SecondaryEndpoints[iNdEx])
			copy(dAtA[i:], m.SecondaryEndpoints[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.SecondaryEndpoints[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if m.GlobalVirtualGroupId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.GlobalVirtualGroupId))
		i--
		dAtA[i] = 0x38
	}
	if m.Sealed {
		i--
		if m.Sealed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if len(m.SecondarySignatures) > 0 {
		for iNdEx := len(m.SecondarySignatures) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SecondarySignatures[iNdEx])
			copy(dAtA[i:], m.SecondarySignatures[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.SecondarySignatures[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.SecondaryAddresses) > 0 {
		for iNdEx := len(m.SecondaryAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SecondaryAddresses[iNdEx])
			copy(dAtA[i:], m.SecondaryAddresses[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.SecondaryAddresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpRecoverPieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GvgId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.GvgId))
		i--
		dAtA[i] = 0x50
	}
	if m.BySuccessorSp {
		i--
		if m.BySuccessorSp {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if m.Recovered {
		i--
		if m.Recovered {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x3a
	}
	if m.PieceSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.PieceSize))
		i--
		dAtA[i] = 0x30
	}
	if m.EcIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.EcIdx))
		i--
		dAtA[i] = 0x28
	}
	if m.SegmentIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.SegmentIdx))
		i--
		dAtA[i] = 0x20
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpReceivePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsAgentUploadTask {
		i--
		if m.IsAgentUploadTask {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.BucketMigration {
		i--
		if m.BucketMigration {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.GlobalVirtualGroupId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.GlobalVirtualGroupId))
		i--
		dAtA[i] = 0x58
	}
	if m.Finished {
		i--
		if m.Finished {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.Sealed {
		i--
		if m.Sealed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.PieceChecksum) > 0 {
		i -= len(m.PieceChecksum)
		copy(dAtA[i:], m.PieceChecksum)
		i = encodeVarintTask(dAtA, i, uint64(len(m.PieceChecksum)))
		i--
		dAtA[i] = 0x3a
	}
	if m.PieceSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.PieceSize))
		i--
		dAtA[i] = 0x30
	}
	if m.RedundancyIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RedundancyIdx))
		i--
		dAtA[i] = 0x28
	}
	if m.SegmentIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.SegmentIdx))
		i--
		dAtA[i] = 0x20
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpSealObjectTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsAgentUploadTask {
		i--
		if m.IsAgentUploadTask {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.SecondaryEndpoints) > 0 {
		for iNdEx := len(m.SecondaryEndpoints) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SecondaryEndpoints[iNdEx])
			copy(dAtA[i:], m.SecondaryEndpoints[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.SecondaryEndpoints[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.GlobalVirtualGroupId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.GlobalVirtualGroupId))
		i--
		dAtA[i] = 0x30
	}
	if len(m.SecondarySignatures) > 0 {
		for iNdEx := len(m.SecondarySignatures) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SecondarySignatures[iNdEx])
			copy(dAtA[i:], m.SecondarySignatures[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.SecondarySignatures[iNdEx])))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.SecondaryAddresses) > 0 {
		for iNdEx := len(m.SecondaryAddresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SecondaryAddresses[iNdEx])
			copy(dAtA[i:], m.SecondaryAddresses[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.SecondaryAddresses[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpDownloadObjectTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.High != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.High))
		i--
		dAtA[i] = 0x30
	}
	if m.Low != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Low))
		i--
		dAtA[i] = 0x28
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.BucketInfo != nil {
		{
			size, err := m.BucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpDownloadPieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PieceLength != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.PieceLength))
		i--
		dAtA[i] = 0x48
	}
	if m.PieceOffset != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.PieceOffset))
		i--
		dAtA[i] = 0x40
	}
	if len(m.PieceKey) > 0 {
		i -= len(m.PieceKey)
		copy(dAtA[i:], m.PieceKey)
		i = encodeVarintTask(dAtA, i, uint64(len(m.PieceKey)))
		i--
		dAtA[i] = 0x3a
	}
	if m.TotalSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.TotalSize))
		i--
		dAtA[i] = 0x30
	}
	if m.EnableCheck {
		i--
		if m.EnableCheck {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.BucketInfo != nil {
		{
			size, err := m.BucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpChallengePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PieceDataSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.PieceDataSize))
		i--
		dAtA[i] = 0x48
	}
	if len(m.PieceHash) > 0 {
		for iNdEx := len(m.PieceHash) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PieceHash[iNdEx])
			copy(dAtA[i:], m.PieceHash[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.PieceHash[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.IntegrityHash) > 0 {
		i -= len(m.IntegrityHash)
		copy(dAtA[i:], m.IntegrityHash)
		i = encodeVarintTask(dAtA, i, uint64(len(m.IntegrityHash)))
		i--
		dAtA[i] = 0x3a
	}
	if m.RedundancyIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RedundancyIdx))
		i--
		dAtA[i] = 0x30
	}
	if m.SegmentIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.SegmentIdx))
		i--
		dAtA[i] = 0x28
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.BucketInfo != nil {
		{
			size, err := m.BucketInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpGCObjectTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Running {
		i--
		if m.Running {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.LastDeletedObjectId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.LastDeletedObjectId))
		i--
		dAtA[i] = 0x28
	}
	if m.CurrentBlockNumber != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CurrentBlockNumber))
		i--
		dAtA[i] = 0x20
	}
	if m.EndBlockNumber != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.EndBlockNumber))
		i--
		dAtA[i] = 0x18
	}
	if m.StartBlockNumber != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.StartBlockNumber))
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpGCZombiePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Finished {
		i--
		if m.Finished {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.EndObjectId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.EndObjectId))
		i--
		dAtA[i] = 0x20
	}
	if m.StartObjectId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.StartObjectId))
		i--
		dAtA[i] = 0x18
	}
	if m.Running {
		i--
		if m.Running {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpGCStaleVersionObjectTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ObjectSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ObjectSize))
		i--
		dAtA[i] = 0x38
	}
	if len(m.PieceChecksumList) > 0 {
		for iNdEx := len(m.PieceChecksumList) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PieceChecksumList[iNdEx])
			copy(dAtA[i:], m.PieceChecksumList[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.PieceChecksumList[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.IntegrityChecksum) > 0 {
		i -= len(m.IntegrityChecksum)
		copy(dAtA[i:], m.IntegrityChecksum)
		i = encodeVarintTask(dAtA, i, uint64(len(m.IntegrityChecksum)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Version != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x20
	}
	if m.RedundancyIndex != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RedundancyIndex))
		i--
		dAtA[i] = 0x18
	}
	if m.ObjectId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ObjectId))
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpGCMetaTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DeleteCount != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.DeleteCount))
		i--
		dAtA[i] = 0x18
	}
	if m.CurrentIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CurrentIdx))
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpMigrateGVGTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MigratedBytesSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MigratedBytesSize))
		i--
		dAtA[i] = 0x58
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x52
	}
	if m.ExpireTime != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ExpireTime))
		i--
		dAtA[i] = 0x48
	}
	if m.Finished {
		i--
		if m.Finished {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.LastMigratedObjectId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.LastMigratedObjectId))
		i--
		dAtA[i] = 0x38
	}
	if m.SrcSp != nil {
		{
			size, err := m.SrcSp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.RedundancyIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RedundancyIdx))
		i--
		dAtA[i] = 0x28
	}
	if m.DestGvg != nil {
		{
			size, err := m.DestGvg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.SrcGvg != nil {
		{
			size, err := m.SrcGvg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BucketId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.BucketId))
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpMigratePieceTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsBucketMigrate {
		i--
		if m.IsBucketMigrate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.RedundancyIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RedundancyIdx))
		i--
		dAtA[i] = 0x30
	}
	if m.SegmentIdx != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.SegmentIdx))
		i--
		dAtA[i] = 0x28
	}
	if len(m.SrcSpEndpoint) > 0 {
		i -= len(m.SrcSpEndpoint)
		copy(dAtA[i:], m.SrcSpEndpoint)
		i = encodeVarintTask(dAtA, i, uint64(len(m.SrcSpEndpoint)))
		i--
		dAtA[i] = 0x22
	}
	if m.StorageParams != nil {
		{
			size, err := m.StorageParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ObjectInfo != nil {
		{
			size, err := m.ObjectInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpGCBucketMigrationTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GcFinishedGvgNum != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.GcFinishedGvgNum))
		i--
		dAtA[i] = 0x38
	}
	if m.TotalGvgNum != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.TotalGvgNum))
		i--
		dAtA[i] = 0x30
	}
	if m.Finished {
		i--
		if m.Finished {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.LastGcGvgId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.LastGcGvgId))
		i--
		dAtA[i] = 0x20
	}
	if m.LastGcObjectId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.LastGcObjectId))
		i--
		dAtA[i] = 0x18
	}
	if m.BucketId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.BucketId))
		i--
		dAtA[i] = 0x10
	}
	if m.Task != nil {
		{
			size, err := m.Task.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpBucketMigrationInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x3a
	}
	if m.ExpireTime != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ExpireTime))
		i--
		dAtA[i] = 0x30
	}
	if m.SrcSp != nil {
		{
			size, err := m.SrcSp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.DestSp != nil {
		{
			size, err := m.DestSp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.MigratedBytesSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MigratedBytesSize))
		i--
		dAtA[i] = 0x18
	}
	if m.Finished {
		i--
		if m.Finished {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.BucketId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.BucketId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *GfSpBucketQuotaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MonthlyFreeQuotaConsumedSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MonthlyFreeQuotaConsumedSize))
		i--
		dAtA[i] = 0x50
	}
	if m.MonthlyFreeQuotaSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MonthlyFreeQuotaSize))
		i--
		dAtA[i] = 0x48
	}
	if m.AllowMigrate {
		i--
		if m.AllowMigrate {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.ChargedQuotaSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ChargedQuotaSize))
		i--
		dAtA[i] = 0x38
	}
	if m.FreeQuotaSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.FreeQuotaSize))
		i--
		dAtA[i] = 0x30
	}
	if m.FreeQuotaConsumedSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.FreeQuotaConsumedSize))
		i--
		dAtA[i] = 0x28
	}
	if m.ReadConsumedSize != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ReadConsumedSize))
		i--
		dAtA[i] = 0x20
	}
	if len(m.BucketName) > 0 {
		i -= len(m.BucketName)
		copy(dAtA[i:], m.BucketName)
		i = encodeVarintTask(dAtA, i, uint64(len(m.BucketName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Month) > 0 {
		i -= len(m.Month)
		copy(dAtA[i:], m.Month)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Month)))
		i--
		dAtA[i] = 0x12
	}
	if m.BucketId != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.BucketId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintTask(dAtA []byte, offset int, v uint64) int {
	offset -= sovTask(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GfSpTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.CreateTime != 0 {
		n += 1 + sovTask(uint64(m.CreateTime))
	}
	if m.UpdateTime != 0 {
		n += 1 + sovTask(uint64(m.UpdateTime))
	}
	if m.Timeout != 0 {
		n += 1 + sovTask(uint64(m.Timeout))
	}
	if m.TaskPriority != 0 {
		n += 1 + sovTask(uint64(m.TaskPriority))
	}
	if m.Retry != 0 {
		n += 1 + sovTask(uint64(m.Retry))
	}
	if m.MaxRetry != 0 {
		n += 1 + sovTask(uint64(m.MaxRetry))
	}
	l = len(m.UserAddress)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Logs)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func (m *GfSpCreateBucketApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.CreateBucketInfo != nil {
		l = m.CreateBucketInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Fingerprint)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func (m *GfSpMigrateBucketApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.MigrateBucketInfo != nil {
		l = m.MigrateBucketInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func (m *GfSpCreateObjectApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.CreateObjectInfo != nil {
		l = m.CreateObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Fingerprint)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func (m *GfSpDelegateCreateObjectApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.DelegateCreateObject != nil {
		l = m.DelegateCreateObject.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Fingerprint)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func (m *GfSpReplicatePieceApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.AskSpOperatorAddress)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.AskSignature)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.ApprovedSpEndpoint)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.ApprovedSpOperatorAddress)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.ApprovedSignature)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.ApprovedSpApprovalAddress)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ExpiredHeight != 0 {
		n += 1 + sovTask(uint64(m.ExpiredHeight))
	}
	return n
}

func (m *GfSpUploadObjectTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.VirtualGroupFamilyId != 0 {
		n += 1 + sovTask(uint64(m.VirtualGroupFamilyId))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.IsAgentUpload {
		n += 2
	}
	return n
}

func (m *GfSpResumableUploadObjectTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovTask(uint64(m.Offset))
	}
	if m.Length != 0 {
		n += 1 + sovTask(uint64(m.Length))
	}
	if m.Completed {
		n += 2
	}
	if m.VirtualGroupFamilyId != 0 {
		n += 1 + sovTask(uint64(m.VirtualGroupFamilyId))
	}
	if m.IsAgentUpload {
		n += 2
	}
	return n
}

func (m *GfSpReplicatePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if len(m.SecondaryAddresses) > 0 {
		for _, s := range m.SecondaryAddresses {
			l = len(s)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if len(m.SecondarySignatures) > 0 {
		for _, b := range m.SecondarySignatures {
			l = len(b)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.Sealed {
		n += 2
	}
	if m.GlobalVirtualGroupId != 0 {
		n += 1 + sovTask(uint64(m.GlobalVirtualGroupId))
	}
	if len(m.SecondaryEndpoints) > 0 {
		for _, s := range m.SecondaryEndpoints {
			l = len(s)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.NotAvailableSpIdx != 0 {
		n += 1 + sovTask(uint64(m.NotAvailableSpIdx))
	}
	if m.IsAgentUploadTask {
		n += 2
	}
	return n
}

func (m *GfSpRecoverPieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.SegmentIdx != 0 {
		n += 1 + sovTask(uint64(m.SegmentIdx))
	}
	if m.EcIdx != 0 {
		n += 1 + sovTask(uint64(m.EcIdx))
	}
	if m.PieceSize != 0 {
		n += 1 + sovTask(uint64(m.PieceSize))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Recovered {
		n += 2
	}
	if m.BySuccessorSp {
		n += 2
	}
	if m.GvgId != 0 {
		n += 1 + sovTask(uint64(m.GvgId))
	}
	return n
}

func (m *GfSpReceivePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.SegmentIdx != 0 {
		n += 1 + sovTask(uint64(m.SegmentIdx))
	}
	if m.RedundancyIdx != 0 {
		n += 1 + sovTask(uint64(m.RedundancyIdx))
	}
	if m.PieceSize != 0 {
		n += 1 + sovTask(uint64(m.PieceSize))
	}
	l = len(m.PieceChecksum)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Sealed {
		n += 2
	}
	if m.Finished {
		n += 2
	}
	if m.GlobalVirtualGroupId != 0 {
		n += 1 + sovTask(uint64(m.GlobalVirtualGroupId))
	}
	if m.BucketMigration {
		n += 2
	}
	if m.IsAgentUploadTask {
		n += 2
	}
	return n
}

func (m *GfSpSealObjectTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if len(m.SecondaryAddresses) > 0 {
		for _, s := range m.SecondaryAddresses {
			l = len(s)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if len(m.SecondarySignatures) > 0 {
		for _, b := range m.SecondarySignatures {
			l = len(b)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.GlobalVirtualGroupId != 0 {
		n += 1 + sovTask(uint64(m.GlobalVirtualGroupId))
	}
	if len(m.SecondaryEndpoints) > 0 {
		for _, s := range m.SecondaryEndpoints {
			l = len(s)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.IsAgentUploadTask {
		n += 2
	}
	return n
}

func (m *GfSpDownloadObjectTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.BucketInfo != nil {
		l = m.BucketInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Low != 0 {
		n += 1 + sovTask(uint64(m.Low))
	}
	if m.High != 0 {
		n += 1 + sovTask(uint64(m.High))
	}
	return n
}

func (m *GfSpDownloadPieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.BucketInfo != nil {
		l = m.BucketInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.EnableCheck {
		n += 2
	}
	if m.TotalSize != 0 {
		n += 1 + sovTask(uint64(m.TotalSize))
	}
	l = len(m.PieceKey)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.PieceOffset != 0 {
		n += 1 + sovTask(uint64(m.PieceOffset))
	}
	if m.PieceLength != 0 {
		n += 1 + sovTask(uint64(m.PieceLength))
	}
	return n
}

func (m *GfSpChallengePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.BucketInfo != nil {
		l = m.BucketInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.SegmentIdx != 0 {
		n += 1 + sovTask(uint64(m.SegmentIdx))
	}
	if m.RedundancyIdx != 0 {
		n += 1 + sovTask(uint64(m.RedundancyIdx))
	}
	l = len(m.IntegrityHash)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if len(m.PieceHash) > 0 {
		for _, b := range m.PieceHash {
			l = len(b)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.PieceDataSize != 0 {
		n += 1 + sovTask(uint64(m.PieceDataSize))
	}
	return n
}

func (m *GfSpGCObjectTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StartBlockNumber != 0 {
		n += 1 + sovTask(uint64(m.StartBlockNumber))
	}
	if m.EndBlockNumber != 0 {
		n += 1 + sovTask(uint64(m.EndBlockNumber))
	}
	if m.CurrentBlockNumber != 0 {
		n += 1 + sovTask(uint64(m.CurrentBlockNumber))
	}
	if m.LastDeletedObjectId != 0 {
		n += 1 + sovTask(uint64(m.LastDeletedObjectId))
	}
	if m.Running {
		n += 2
	}
	return n
}

func (m *GfSpGCZombiePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Running {
		n += 2
	}
	if m.StartObjectId != 0 {
		n += 1 + sovTask(uint64(m.StartObjectId))
	}
	if m.EndObjectId != 0 {
		n += 1 + sovTask(uint64(m.EndObjectId))
	}
	if m.Finished {
		n += 2
	}
	return n
}

func (m *GfSpGCStaleVersionObjectTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectId != 0 {
		n += 1 + sovTask(uint64(m.ObjectId))
	}
	if m.RedundancyIndex != 0 {
		n += 1 + sovTask(uint64(m.RedundancyIndex))
	}
	if m.Version != 0 {
		n += 1 + sovTask(uint64(m.Version))
	}
	l = len(m.IntegrityChecksum)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if len(m.PieceChecksumList) > 0 {
		for _, b := range m.PieceChecksumList {
			l = len(b)
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.ObjectSize != 0 {
		n += 1 + sovTask(uint64(m.ObjectSize))
	}
	return n
}

func (m *GfSpGCMetaTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.CurrentIdx != 0 {
		n += 1 + sovTask(uint64(m.CurrentIdx))
	}
	if m.DeleteCount != 0 {
		n += 1 + sovTask(uint64(m.DeleteCount))
	}
	return n
}

func (m *GfSpMigrateGVGTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.BucketId != 0 {
		n += 1 + sovTask(uint64(m.BucketId))
	}
	if m.SrcGvg != nil {
		l = m.SrcGvg.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.DestGvg != nil {
		l = m.DestGvg.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.RedundancyIdx != 0 {
		n += 1 + sovTask(uint64(m.RedundancyIdx))
	}
	if m.SrcSp != nil {
		l = m.SrcSp.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.LastMigratedObjectId != 0 {
		n += 1 + sovTask(uint64(m.LastMigratedObjectId))
	}
	if m.Finished {
		n += 2
	}
	if m.ExpireTime != 0 {
		n += 1 + sovTask(uint64(m.ExpireTime))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.MigratedBytesSize != 0 {
		n += 1 + sovTask(uint64(m.MigratedBytesSize))
	}
	return n
}

func (m *GfSpMigratePieceTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ObjectInfo != nil {
		l = m.ObjectInfo.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.StorageParams != nil {
		l = m.StorageParams.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.SrcSpEndpoint)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.SegmentIdx != 0 {
		n += 1 + sovTask(uint64(m.SegmentIdx))
	}
	if m.RedundancyIdx != 0 {
		n += 1 + sovTask(uint64(m.RedundancyIdx))
	}
	if m.IsBucketMigrate {
		n += 2
	}
	return n
}

func (m *GfSpGCBucketMigrationTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.BucketId != 0 {
		n += 1 + sovTask(uint64(m.BucketId))
	}
	if m.LastGcObjectId != 0 {
		n += 1 + sovTask(uint64(m.LastGcObjectId))
	}
	if m.LastGcGvgId != 0 {
		n += 1 + sovTask(uint64(m.LastGcGvgId))
	}
	if m.Finished {
		n += 2
	}
	if m.TotalGvgNum != 0 {
		n += 1 + sovTask(uint64(m.TotalGvgNum))
	}
	if m.GcFinishedGvgNum != 0 {
		n += 1 + sovTask(uint64(m.GcFinishedGvgNum))
	}
	return n
}

func (m *GfSpBucketMigrationInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BucketId != 0 {
		n += 1 + sovTask(uint64(m.BucketId))
	}
	if m.Finished {
		n += 2
	}
	if m.MigratedBytesSize != 0 {
		n += 1 + sovTask(uint64(m.MigratedBytesSize))
	}
	if m.DestSp != nil {
		l = m.DestSp.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.SrcSp != nil {
		l = m.SrcSp.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ExpireTime != 0 {
		n += 1 + sovTask(uint64(m.ExpireTime))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func (m *GfSpBucketQuotaInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BucketId != 0 {
		n += 1 + sovTask(uint64(m.BucketId))
	}
	l = len(m.Month)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.BucketName)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.ReadConsumedSize != 0 {
		n += 1 + sovTask(uint64(m.ReadConsumedSize))
	}
	if m.FreeQuotaConsumedSize != 0 {
		n += 1 + sovTask(uint64(m.FreeQuotaConsumedSize))
	}
	if m.FreeQuotaSize != 0 {
		n += 1 + sovTask(uint64(m.FreeQuotaSize))
	}
	if m.ChargedQuotaSize != 0 {
		n += 1 + sovTask(uint64(m.ChargedQuotaSize))
	}
	if m.AllowMigrate {
		n += 2
	}
	if m.MonthlyFreeQuotaSize != 0 {
		n += 1 + sovTask(uint64(m.MonthlyFreeQuotaSize))
	}
	if m.MonthlyFreeQuotaConsumedSize != 0 {
		n += 1 + sovTask(uint64(m.MonthlyFreeQuotaConsumedSize))
	}
	return n
}

func sovTask(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTask(x uint64) (n int) {
	return sovTask(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GfSpTask) 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 ErrIntOverflowTask
			}
			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: GfSpTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
			}
			m.CreateTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
			}
			m.UpdateTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdateTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskPriority", wireType)
			}
			m.TaskPriority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskPriority |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Retry", wireType)
			}
			m.Retry = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Retry |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRetry", wireType)
			}
			m.MaxRetry = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRetry |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &gfsperrors.GfSpError{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpCreateBucketApprovalTask) 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 ErrIntOverflowTask
			}
			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: GfSpCreateBucketApprovalTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpCreateBucketApprovalTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateBucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreateBucketInfo == nil {
				m.CreateBucketInfo = &types.MsgCreateBucket{}
			}
			if err := m.CreateBucketInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fingerprint", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fingerprint = append(m.Fingerprint[:0], dAtA[iNdEx:postIndex]...)
			if m.Fingerprint == nil {
				m.Fingerprint = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpCreateObjectApprovalTask) 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 ErrIntOverflowTask
			}
			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: GfSpCreateObjectApprovalTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpCreateObjectApprovalTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreateObjectInfo == nil {
				m.CreateObjectInfo = &types.MsgCreateObject{}
			}
			if err := m.CreateObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fingerprint", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fingerprint = append(m.Fingerprint[:0], dAtA[iNdEx:postIndex]...)
			if m.Fingerprint == nil {
				m.Fingerprint = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpDelegateCreateObjectApprovalTask) 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 ErrIntOverflowTask
			}
			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: GfSpDelegateCreateObjectApprovalTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpDelegateCreateObjectApprovalTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateCreateObject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DelegateCreateObject == nil {
				m.DelegateCreateObject = &types.MsgDelegateCreateObject{}
			}
			if err := m.DelegateCreateObject.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fingerprint", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fingerprint = append(m.Fingerprint[:0], dAtA[iNdEx:postIndex]...)
			if m.Fingerprint == nil {
				m.Fingerprint = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpReplicatePieceApprovalTask) 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 ErrIntOverflowTask
			}
			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: GfSpReplicatePieceApprovalTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpReplicatePieceApprovalTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AskSpOperatorAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AskSpOperatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AskSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AskSignature = append(m.AskSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.AskSignature == nil {
				m.AskSignature = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApprovedSpEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApprovedSpEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApprovedSpOperatorAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApprovedSpOperatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApprovedSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApprovedSignature = append(m.ApprovedSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.ApprovedSignature == nil {
				m.ApprovedSignature = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApprovedSpApprovalAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApprovedSpApprovalAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpiredHeight", wireType)
			}
			m.ExpiredHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpiredHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpUploadObjectTask) 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 ErrIntOverflowTask
			}
			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: GfSpUploadObjectTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpUploadObjectTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualGroupFamilyId", wireType)
			}
			m.VirtualGroupFamilyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VirtualGroupFamilyId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAgentUpload", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAgentUpload = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpResumableUploadObjectTask) 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 ErrIntOverflowTask
			}
			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: GfSpResumableUploadObjectTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpResumableUploadObjectTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
			}
			m.Length = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Length |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Completed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Completed = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VirtualGroupFamilyId", wireType)
			}
			m.VirtualGroupFamilyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VirtualGroupFamilyId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAgentUpload", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAgentUpload = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpReplicatePieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpReplicatePieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpReplicatePieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondaryAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondaryAddresses = append(m.SecondaryAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondarySignatures", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondarySignatures = append(m.SecondarySignatures, make([]byte, postIndex-iNdEx))
			copy(m.SecondarySignatures[len(m.SecondarySignatures)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sealed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Sealed = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType)
			}
			m.GlobalVirtualGroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondaryEndpoints", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondaryEndpoints = append(m.SecondaryEndpoints, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotAvailableSpIdx", wireType)
			}
			m.NotAvailableSpIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NotAvailableSpIdx |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAgentUploadTask", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAgentUploadTask = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpRecoverPieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpRecoverPieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpRecoverPieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SegmentIdx", wireType)
			}
			m.SegmentIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SegmentIdx |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EcIdx", wireType)
			}
			m.EcIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EcIdx |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceSize", wireType)
			}
			m.PieceSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PieceSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recovered", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Recovered = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BySuccessorSp", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BySuccessorSp = bool(v != 0)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GvgId", wireType)
			}
			m.GvgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GvgId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpReceivePieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpReceivePieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpReceivePieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SegmentIdx", wireType)
			}
			m.SegmentIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SegmentIdx |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIdx", wireType)
			}
			m.RedundancyIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedundancyIdx |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceSize", wireType)
			}
			m.PieceSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PieceSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceChecksum", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PieceChecksum = append(m.PieceChecksum[:0], dAtA[iNdEx:postIndex]...)
			if m.PieceChecksum == nil {
				m.PieceChecksum = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sealed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Sealed = bool(v != 0)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Finished = bool(v != 0)
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType)
			}
			m.GlobalVirtualGroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketMigration", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BucketMigration = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAgentUploadTask", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAgentUploadTask = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpSealObjectTask) 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 ErrIntOverflowTask
			}
			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: GfSpSealObjectTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpSealObjectTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondaryAddresses", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondaryAddresses = append(m.SecondaryAddresses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondarySignatures", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondarySignatures = append(m.SecondarySignatures, make([]byte, postIndex-iNdEx))
			copy(m.SecondarySignatures[len(m.SecondarySignatures)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType)
			}
			m.GlobalVirtualGroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondaryEndpoints", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SecondaryEndpoints = append(m.SecondaryEndpoints, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAgentUploadTask", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsAgentUploadTask = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpDownloadObjectTask) 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 ErrIntOverflowTask
			}
			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: GfSpDownloadObjectTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpDownloadObjectTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BucketInfo == nil {
				m.BucketInfo = &types.BucketInfo{}
			}
			if err := m.BucketInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Low", wireType)
			}
			m.Low = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Low |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field High", wireType)
			}
			m.High = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.High |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpDownloadPieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpDownloadPieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpDownloadPieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BucketInfo == nil {
				m.BucketInfo = &types.BucketInfo{}
			}
			if err := m.BucketInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableCheck", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableCheck = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)
			}
			m.TotalSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PieceKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceOffset", wireType)
			}
			m.PieceOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PieceOffset |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceLength", wireType)
			}
			m.PieceLength = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PieceLength |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpChallengePieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpChallengePieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpChallengePieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BucketInfo == nil {
				m.BucketInfo = &types.BucketInfo{}
			}
			if err := m.BucketInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SegmentIdx", wireType)
			}
			m.SegmentIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SegmentIdx |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIdx", wireType)
			}
			m.RedundancyIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedundancyIdx |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntegrityHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IntegrityHash = append(m.IntegrityHash[:0], dAtA[iNdEx:postIndex]...)
			if m.IntegrityHash == nil {
				m.IntegrityHash = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PieceHash = append(m.PieceHash, make([]byte, postIndex-iNdEx))
			copy(m.PieceHash[len(m.PieceHash)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceDataSize", wireType)
			}
			m.PieceDataSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PieceDataSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpGCObjectTask) 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 ErrIntOverflowTask
			}
			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: GfSpGCObjectTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpGCObjectTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartBlockNumber", wireType)
			}
			m.StartBlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartBlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndBlockNumber", wireType)
			}
			m.EndBlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EndBlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentBlockNumber", wireType)
			}
			m.CurrentBlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentBlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastDeletedObjectId", wireType)
			}
			m.LastDeletedObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastDeletedObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Running", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Running = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpGCZombiePieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpGCZombiePieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpGCZombiePieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Running", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Running = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartObjectId", wireType)
			}
			m.StartObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndObjectId", wireType)
			}
			m.EndObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EndObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Finished = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpGCStaleVersionObjectTask) 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 ErrIntOverflowTask
			}
			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: GfSpGCStaleVersionObjectTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpGCStaleVersionObjectTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType)
			}
			m.ObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIndex", wireType)
			}
			m.RedundancyIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedundancyIndex |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntegrityChecksum", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IntegrityChecksum = append(m.IntegrityChecksum[:0], dAtA[iNdEx:postIndex]...)
			if m.IntegrityChecksum == nil {
				m.IntegrityChecksum = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PieceChecksumList", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PieceChecksumList = append(m.PieceChecksumList, make([]byte, postIndex-iNdEx))
			copy(m.PieceChecksumList[len(m.PieceChecksumList)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectSize", wireType)
			}
			m.ObjectSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObjectSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpMigrateGVGTask) 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 ErrIntOverflowTask
			}
			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: GfSpMigrateGVGTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpMigrateGVGTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType)
			}
			m.BucketId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcGvg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SrcGvg == nil {
				m.SrcGvg = &types1.GlobalVirtualGroup{}
			}
			if err := m.SrcGvg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestGvg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DestGvg == nil {
				m.DestGvg = &types1.GlobalVirtualGroup{}
			}
			if err := m.DestGvg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIdx", wireType)
			}
			m.RedundancyIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedundancyIdx |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcSp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SrcSp == nil {
				m.SrcSp = &types2.StorageProvider{}
			}
			if err := m.SrcSp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastMigratedObjectId", wireType)
			}
			m.LastMigratedObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastMigratedObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Finished = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpireTime", wireType)
			}
			m.ExpireTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpireTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MigratedBytesSize", wireType)
			}
			m.MigratedBytesSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MigratedBytesSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpMigratePieceTask) 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 ErrIntOverflowTask
			}
			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: GfSpMigratePieceTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpMigratePieceTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ObjectInfo == nil {
				m.ObjectInfo = &types.ObjectInfo{}
			}
			if err := m.ObjectInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StorageParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StorageParams == nil {
				m.StorageParams = &types.Params{}
			}
			if err := m.StorageParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcSpEndpoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcSpEndpoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SegmentIdx", wireType)
			}
			m.SegmentIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SegmentIdx |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedundancyIdx", wireType)
			}
			m.RedundancyIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RedundancyIdx |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsBucketMigrate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsBucketMigrate = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpGCBucketMigrationTask) 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 ErrIntOverflowTask
			}
			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: GfSpGCBucketMigrationTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpGCBucketMigrationTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Task == nil {
				m.Task = &GfSpTask{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType)
			}
			m.BucketId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastGcObjectId", wireType)
			}
			m.LastGcObjectId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastGcObjectId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastGcGvgId", wireType)
			}
			m.LastGcGvgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastGcGvgId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Finished = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalGvgNum", wireType)
			}
			m.TotalGvgNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalGvgNum |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GcFinishedGvgNum", wireType)
			}
			m.GcFinishedGvgNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GcFinishedGvgNum |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpBucketMigrationInfo) 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 ErrIntOverflowTask
			}
			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: GfSpBucketMigrationInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpBucketMigrationInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType)
			}
			m.BucketId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Finished", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Finished = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MigratedBytesSize", wireType)
			}
			m.MigratedBytesSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MigratedBytesSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestSp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DestSp == nil {
				m.DestSp = &types2.StorageProvider{}
			}
			if err := m.DestSp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcSp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SrcSp == nil {
				m.SrcSp = &types2.StorageProvider{}
			}
			if err := m.SrcSp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpireTime", wireType)
			}
			m.ExpireTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpireTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpBucketQuotaInfo) 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 ErrIntOverflowTask
			}
			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: GfSpBucketQuotaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpBucketQuotaInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketId", wireType)
			}
			m.BucketId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BucketId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Month", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Month = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BucketName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadConsumedSize", wireType)
			}
			m.ReadConsumedSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadConsumedSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FreeQuotaConsumedSize", wireType)
			}
			m.FreeQuotaConsumedSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FreeQuotaConsumedSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FreeQuotaSize", wireType)
			}
			m.FreeQuotaSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FreeQuotaSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChargedQuotaSize", wireType)
			}
			m.ChargedQuotaSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChargedQuotaSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowMigrate", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowMigrate = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MonthlyFreeQuotaSize", wireType)
			}
			m.MonthlyFreeQuotaSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MonthlyFreeQuotaSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MonthlyFreeQuotaConsumedSize", wireType)
			}
			m.MonthlyFreeQuotaConsumedSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MonthlyFreeQuotaConsumedSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTask        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTask          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTask = fmt.Errorf("proto: unexpected end of group")
)
