task.pb.go

// 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 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{4}
}
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"`
}

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{5}
}
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
}

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"`
}

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{6}
}
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
}

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"`
}

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{7}
}
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
}

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"`
}

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{8}
}
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
}

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"`
}

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{9}
}
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
}

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"`
}

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{10}
}
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
}

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{11}
}
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{12}
}
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{13}
}
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{14}
}
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"`
	ObjectId    uint64    `protobuf:"varint,2,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
	DeleteCount uint64    `protobuf:"varint,3,opt,name=delete_count,json=deleteCount,proto3" json:"delete_count,omitempty"`
	Running     bool      `protobuf:"varint,4,opt,name=running,proto3" json:"running,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{15}
}
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) GetObjectId() uint64 {
	if m != nil {
		return m.ObjectId
	}
	return 0
}

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

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

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"`
	Running     bool      `protobuf:"varint,4,opt,name=running,proto3" json:"running,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{16}
}
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
}

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

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"`
}

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{17}
}
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
}

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"`
	Signature       []byte            `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
	IsBucketMigrate bool              `protobuf:"varint,8,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{18}
}
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) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

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

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((*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((*GfSpGCMetaTask)(nil), "base.types.gfsptask.GfSpGCMetaTask")
	proto.RegisterType((*GfSpMigrateGVGTask)(nil), "base.types.gfsptask.GfSpMigrateGVGTask")
	proto.RegisterType((*GfSpMigratePieceTask)(nil), "base.types.gfsptask.GfSpMigratePieceTask")
}

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

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