// Code generated by protoc-gen-go. DO NOT EDIT.
// source: datatransfer.proto

package hadoop_hdfs

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import hadoop_common "github.com/colinmarc/hdfs/protocol/hadoop_common"

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

// Status is a 4-bit enum
type Status int32

const (
	Status_SUCCESS            Status = 0
	Status_ERROR              Status = 1
	Status_ERROR_CHECKSUM     Status = 2
	Status_ERROR_INVALID      Status = 3
	Status_ERROR_EXISTS       Status = 4
	Status_ERROR_ACCESS_TOKEN Status = 5
	Status_CHECKSUM_OK        Status = 6
	Status_ERROR_UNSUPPORTED  Status = 7
	Status_OOB_RESTART        Status = 8
	Status_OOB_RESERVED1      Status = 9
	Status_OOB_RESERVED2      Status = 10
	Status_OOB_RESERVED3      Status = 11
	Status_IN_PROGRESS        Status = 12
)

var Status_name = map[int32]string{
	0:  "SUCCESS",
	1:  "ERROR",
	2:  "ERROR_CHECKSUM",
	3:  "ERROR_INVALID",
	4:  "ERROR_EXISTS",
	5:  "ERROR_ACCESS_TOKEN",
	6:  "CHECKSUM_OK",
	7:  "ERROR_UNSUPPORTED",
	8:  "OOB_RESTART",
	9:  "OOB_RESERVED1",
	10: "OOB_RESERVED2",
	11: "OOB_RESERVED3",
	12: "IN_PROGRESS",
}
var Status_value = map[string]int32{
	"SUCCESS":            0,
	"ERROR":              1,
	"ERROR_CHECKSUM":     2,
	"ERROR_INVALID":      3,
	"ERROR_EXISTS":       4,
	"ERROR_ACCESS_TOKEN": 5,
	"CHECKSUM_OK":        6,
	"ERROR_UNSUPPORTED":  7,
	"OOB_RESTART":        8,
	"OOB_RESERVED1":      9,
	"OOB_RESERVED2":      10,
	"OOB_RESERVED3":      11,
	"IN_PROGRESS":        12,
}

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

type ShortCircuitFdResponse int32

const (
	ShortCircuitFdResponse_DO_NOT_USE_RECEIPT_VERIFICATION ShortCircuitFdResponse = 0
	ShortCircuitFdResponse_USE_RECEIPT_VERIFICATION        ShortCircuitFdResponse = 1
)

var ShortCircuitFdResponse_name = map[int32]string{
	0: "DO_NOT_USE_RECEIPT_VERIFICATION",
	1: "USE_RECEIPT_VERIFICATION",
}
var ShortCircuitFdResponse_value = map[string]int32{
	"DO_NOT_USE_RECEIPT_VERIFICATION": 0,
	"USE_RECEIPT_VERIFICATION":        1,
}

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

type DataTransferEncryptorMessageProto_DataTransferEncryptorStatus int32

const (
	DataTransferEncryptorMessageProto_SUCCESS           DataTransferEncryptorMessageProto_DataTransferEncryptorStatus = 0
	DataTransferEncryptorMessageProto_ERROR_UNKNOWN_KEY DataTransferEncryptorMessageProto_DataTransferEncryptorStatus = 1
	DataTransferEncryptorMessageProto_ERROR             DataTransferEncryptorMessageProto_DataTransferEncryptorStatus = 2
)

var DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_name = map[int32]string{
	0: "SUCCESS",
	1: "ERROR_UNKNOWN_KEY",
	2: "ERROR",
}
var DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_value = map[string]int32{
	"SUCCESS":           0,
	"ERROR_UNKNOWN_KEY": 1,
	"ERROR":             2,
}

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

type OpWriteBlockProto_BlockConstructionStage int32

const (
	OpWriteBlockProto_PIPELINE_SETUP_APPEND OpWriteBlockProto_BlockConstructionStage = 0
	// pipeline set up for failed PIPELINE_SETUP_APPEND recovery
	OpWriteBlockProto_PIPELINE_SETUP_APPEND_RECOVERY OpWriteBlockProto_BlockConstructionStage = 1
	// data streaming
	OpWriteBlockProto_DATA_STREAMING OpWriteBlockProto_BlockConstructionStage = 2
	// pipeline setup for failed data streaming recovery
	OpWriteBlockProto_PIPELINE_SETUP_STREAMING_RECOVERY OpWriteBlockProto_BlockConstructionStage = 3
	// close the block and pipeline
	OpWriteBlockProto_PIPELINE_CLOSE OpWriteBlockProto_BlockConstructionStage = 4
	// Recover a failed PIPELINE_CLOSE
	OpWriteBlockProto_PIPELINE_CLOSE_RECOVERY OpWriteBlockProto_BlockConstructionStage = 5
	// pipeline set up for block creation
	OpWriteBlockProto_PIPELINE_SETUP_CREATE OpWriteBlockProto_BlockConstructionStage = 6
	// transfer RBW for adding datanodes
	OpWriteBlockProto_TRANSFER_RBW OpWriteBlockProto_BlockConstructionStage = 7
	// transfer Finalized for adding datanodes
	OpWriteBlockProto_TRANSFER_FINALIZED OpWriteBlockProto_BlockConstructionStage = 8
)

var OpWriteBlockProto_BlockConstructionStage_name = map[int32]string{
	0: "PIPELINE_SETUP_APPEND",
	1: "PIPELINE_SETUP_APPEND_RECOVERY",
	2: "DATA_STREAMING",
	3: "PIPELINE_SETUP_STREAMING_RECOVERY",
	4: "PIPELINE_CLOSE",
	5: "PIPELINE_CLOSE_RECOVERY",
	6: "PIPELINE_SETUP_CREATE",
	7: "TRANSFER_RBW",
	8: "TRANSFER_FINALIZED",
}
var OpWriteBlockProto_BlockConstructionStage_value = map[string]int32{
	"PIPELINE_SETUP_APPEND":             0,
	"PIPELINE_SETUP_APPEND_RECOVERY":    1,
	"DATA_STREAMING":                    2,
	"PIPELINE_SETUP_STREAMING_RECOVERY": 3,
	"PIPELINE_CLOSE":                    4,
	"PIPELINE_CLOSE_RECOVERY":           5,
	"PIPELINE_SETUP_CREATE":             6,
	"TRANSFER_RBW":                      7,
	"TRANSFER_FINALIZED":                8,
}

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

type DataTransferEncryptorMessageProto struct {
	Status           *DataTransferEncryptorMessageProto_DataTransferEncryptorStatus `protobuf:"varint,1,req,name=status,enum=hadoop.hdfs.DataTransferEncryptorMessageProto_DataTransferEncryptorStatus" json:"status,omitempty"`
	Payload          []byte                                                         `protobuf:"bytes,2,opt,name=payload" json:"payload,omitempty"`
	Message          *string                                                        `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
	CipherOption     []*CipherOptionProto                                           `protobuf:"bytes,4,rep,name=cipherOption" json:"cipherOption,omitempty"`
	XXX_unrecognized []byte                                                         `json:"-"`
}

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

func (m *DataTransferEncryptorMessageProto) GetStatus() DataTransferEncryptorMessageProto_DataTransferEncryptorStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return DataTransferEncryptorMessageProto_SUCCESS
}

func (m *DataTransferEncryptorMessageProto) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

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

func (m *DataTransferEncryptorMessageProto) GetCipherOption() []*CipherOptionProto {
	if m != nil {
		return m.CipherOption
	}
	return nil
}

type BaseHeaderProto struct {
	Block            *ExtendedBlockProto         `protobuf:"bytes,1,req,name=block" json:"block,omitempty"`
	Token            *hadoop_common.TokenProto   `protobuf:"bytes,2,opt,name=token" json:"token,omitempty"`
	TraceInfo        *DataTransferTraceInfoProto `protobuf:"bytes,3,opt,name=traceInfo" json:"traceInfo,omitempty"`
	XXX_unrecognized []byte                      `json:"-"`
}

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

func (m *BaseHeaderProto) GetBlock() *ExtendedBlockProto {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *BaseHeaderProto) GetToken() *hadoop_common.TokenProto {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *BaseHeaderProto) GetTraceInfo() *DataTransferTraceInfoProto {
	if m != nil {
		return m.TraceInfo
	}
	return nil
}

type DataTransferTraceInfoProto struct {
	TraceId          *uint64 `protobuf:"varint,1,req,name=traceId" json:"traceId,omitempty"`
	ParentId         *uint64 `protobuf:"varint,2,req,name=parentId" json:"parentId,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *DataTransferTraceInfoProto) GetTraceId() uint64 {
	if m != nil && m.TraceId != nil {
		return *m.TraceId
	}
	return 0
}

func (m *DataTransferTraceInfoProto) GetParentId() uint64 {
	if m != nil && m.ParentId != nil {
		return *m.ParentId
	}
	return 0
}

type ClientOperationHeaderProto struct {
	BaseHeader       *BaseHeaderProto `protobuf:"bytes,1,req,name=baseHeader" json:"baseHeader,omitempty"`
	ClientName       *string          `protobuf:"bytes,2,req,name=clientName" json:"clientName,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *ClientOperationHeaderProto) GetBaseHeader() *BaseHeaderProto {
	if m != nil {
		return m.BaseHeader
	}
	return nil
}

func (m *ClientOperationHeaderProto) GetClientName() string {
	if m != nil && m.ClientName != nil {
		return *m.ClientName
	}
	return ""
}

type CachingStrategyProto struct {
	DropBehind       *bool  `protobuf:"varint,1,opt,name=dropBehind" json:"dropBehind,omitempty"`
	Readahead        *int64 `protobuf:"varint,2,opt,name=readahead" json:"readahead,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *CachingStrategyProto) GetDropBehind() bool {
	if m != nil && m.DropBehind != nil {
		return *m.DropBehind
	}
	return false
}

func (m *CachingStrategyProto) GetReadahead() int64 {
	if m != nil && m.Readahead != nil {
		return *m.Readahead
	}
	return 0
}

type OpReadBlockProto struct {
	Header           *ClientOperationHeaderProto `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	Offset           *uint64                     `protobuf:"varint,2,req,name=offset" json:"offset,omitempty"`
	Len              *uint64                     `protobuf:"varint,3,req,name=len" json:"len,omitempty"`
	SendChecksums    *bool                       `protobuf:"varint,4,opt,name=sendChecksums,def=1" json:"sendChecksums,omitempty"`
	CachingStrategy  *CachingStrategyProto       `protobuf:"bytes,5,opt,name=cachingStrategy" json:"cachingStrategy,omitempty"`
	XXX_unrecognized []byte                      `json:"-"`
}

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

const Default_OpReadBlockProto_SendChecksums bool = true

func (m *OpReadBlockProto) GetHeader() *ClientOperationHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

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

func (m *OpReadBlockProto) GetLen() uint64 {
	if m != nil && m.Len != nil {
		return *m.Len
	}
	return 0
}

func (m *OpReadBlockProto) GetSendChecksums() bool {
	if m != nil && m.SendChecksums != nil {
		return *m.SendChecksums
	}
	return Default_OpReadBlockProto_SendChecksums
}

func (m *OpReadBlockProto) GetCachingStrategy() *CachingStrategyProto {
	if m != nil {
		return m.CachingStrategy
	}
	return nil
}

type ChecksumProto struct {
	Type             *ChecksumTypeProto `protobuf:"varint,1,req,name=type,enum=hadoop.hdfs.ChecksumTypeProto" json:"type,omitempty"`
	BytesPerChecksum *uint32            `protobuf:"varint,2,req,name=bytesPerChecksum" json:"bytesPerChecksum,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

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

func (m *ChecksumProto) GetType() ChecksumTypeProto {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ChecksumTypeProto_CHECKSUM_NULL
}

func (m *ChecksumProto) GetBytesPerChecksum() uint32 {
	if m != nil && m.BytesPerChecksum != nil {
		return *m.BytesPerChecksum
	}
	return 0
}

type OpWriteBlockProto struct {
	Header                *ClientOperationHeaderProto               `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	Targets               []*DatanodeInfoProto                      `protobuf:"bytes,2,rep,name=targets" json:"targets,omitempty"`
	Source                *DatanodeInfoProto                        `protobuf:"bytes,3,opt,name=source" json:"source,omitempty"`
	Stage                 *OpWriteBlockProto_BlockConstructionStage `protobuf:"varint,4,req,name=stage,enum=hadoop.hdfs.OpWriteBlockProto_BlockConstructionStage" json:"stage,omitempty"`
	PipelineSize          *uint32                                   `protobuf:"varint,5,req,name=pipelineSize" json:"pipelineSize,omitempty"`
	MinBytesRcvd          *uint64                                   `protobuf:"varint,6,req,name=minBytesRcvd" json:"minBytesRcvd,omitempty"`
	MaxBytesRcvd          *uint64                                   `protobuf:"varint,7,req,name=maxBytesRcvd" json:"maxBytesRcvd,omitempty"`
	LatestGenerationStamp *uint64                                   `protobuf:"varint,8,req,name=latestGenerationStamp" json:"latestGenerationStamp,omitempty"`
	// *
	// The requested checksum mechanism for this block write.
	RequestedChecksum  *ChecksumProto        `protobuf:"bytes,9,req,name=requestedChecksum" json:"requestedChecksum,omitempty"`
	CachingStrategy    *CachingStrategyProto `protobuf:"bytes,10,opt,name=cachingStrategy" json:"cachingStrategy,omitempty"`
	StorageType        *StorageTypeProto     `protobuf:"varint,11,opt,name=storageType,enum=hadoop.hdfs.StorageTypeProto,def=1" json:"storageType,omitempty"`
	TargetStorageTypes []StorageTypeProto    `protobuf:"varint,12,rep,name=targetStorageTypes,enum=hadoop.hdfs.StorageTypeProto" json:"targetStorageTypes,omitempty"`
	// *
	// Hint to the DataNode that the block can be allocated on transient
	// storage i.e. memory and written to disk lazily. The DataNode is free
	// to ignore this hint.
	AllowLazyPersist *bool `protobuf:"varint,13,opt,name=allowLazyPersist,def=0" json:"allowLazyPersist,omitempty"`
	// whether to pin the block, so Balancer won't move it.
	Pinning          *bool  `protobuf:"varint,14,opt,name=pinning,def=0" json:"pinning,omitempty"`
	TargetPinnings   []bool `protobuf:"varint,15,rep,name=targetPinnings" json:"targetPinnings,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

const Default_OpWriteBlockProto_StorageType StorageTypeProto = StorageTypeProto_DISK
const Default_OpWriteBlockProto_AllowLazyPersist bool = false
const Default_OpWriteBlockProto_Pinning bool = false

func (m *OpWriteBlockProto) GetHeader() *ClientOperationHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *OpWriteBlockProto) GetTargets() []*DatanodeInfoProto {
	if m != nil {
		return m.Targets
	}
	return nil
}

func (m *OpWriteBlockProto) GetSource() *DatanodeInfoProto {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *OpWriteBlockProto) GetStage() OpWriteBlockProto_BlockConstructionStage {
	if m != nil && m.Stage != nil {
		return *m.Stage
	}
	return OpWriteBlockProto_PIPELINE_SETUP_APPEND
}

func (m *OpWriteBlockProto) GetPipelineSize() uint32 {
	if m != nil && m.PipelineSize != nil {
		return *m.PipelineSize
	}
	return 0
}

func (m *OpWriteBlockProto) GetMinBytesRcvd() uint64 {
	if m != nil && m.MinBytesRcvd != nil {
		return *m.MinBytesRcvd
	}
	return 0
}

func (m *OpWriteBlockProto) GetMaxBytesRcvd() uint64 {
	if m != nil && m.MaxBytesRcvd != nil {
		return *m.MaxBytesRcvd
	}
	return 0
}

func (m *OpWriteBlockProto) GetLatestGenerationStamp() uint64 {
	if m != nil && m.LatestGenerationStamp != nil {
		return *m.LatestGenerationStamp
	}
	return 0
}

func (m *OpWriteBlockProto) GetRequestedChecksum() *ChecksumProto {
	if m != nil {
		return m.RequestedChecksum
	}
	return nil
}

func (m *OpWriteBlockProto) GetCachingStrategy() *CachingStrategyProto {
	if m != nil {
		return m.CachingStrategy
	}
	return nil
}

func (m *OpWriteBlockProto) GetStorageType() StorageTypeProto {
	if m != nil && m.StorageType != nil {
		return *m.StorageType
	}
	return Default_OpWriteBlockProto_StorageType
}

func (m *OpWriteBlockProto) GetTargetStorageTypes() []StorageTypeProto {
	if m != nil {
		return m.TargetStorageTypes
	}
	return nil
}

func (m *OpWriteBlockProto) GetAllowLazyPersist() bool {
	if m != nil && m.AllowLazyPersist != nil {
		return *m.AllowLazyPersist
	}
	return Default_OpWriteBlockProto_AllowLazyPersist
}

func (m *OpWriteBlockProto) GetPinning() bool {
	if m != nil && m.Pinning != nil {
		return *m.Pinning
	}
	return Default_OpWriteBlockProto_Pinning
}

func (m *OpWriteBlockProto) GetTargetPinnings() []bool {
	if m != nil {
		return m.TargetPinnings
	}
	return nil
}

type OpTransferBlockProto struct {
	Header             *ClientOperationHeaderProto `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	Targets            []*DatanodeInfoProto        `protobuf:"bytes,2,rep,name=targets" json:"targets,omitempty"`
	TargetStorageTypes []StorageTypeProto          `protobuf:"varint,3,rep,name=targetStorageTypes,enum=hadoop.hdfs.StorageTypeProto" json:"targetStorageTypes,omitempty"`
	XXX_unrecognized   []byte                      `json:"-"`
}

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

func (m *OpTransferBlockProto) GetHeader() *ClientOperationHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *OpTransferBlockProto) GetTargets() []*DatanodeInfoProto {
	if m != nil {
		return m.Targets
	}
	return nil
}

func (m *OpTransferBlockProto) GetTargetStorageTypes() []StorageTypeProto {
	if m != nil {
		return m.TargetStorageTypes
	}
	return nil
}

type OpReplaceBlockProto struct {
	Header           *BaseHeaderProto   `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	DelHint          *string            `protobuf:"bytes,2,req,name=delHint" json:"delHint,omitempty"`
	Source           *DatanodeInfoProto `protobuf:"bytes,3,req,name=source" json:"source,omitempty"`
	StorageType      *StorageTypeProto  `protobuf:"varint,4,opt,name=storageType,enum=hadoop.hdfs.StorageTypeProto,def=1" json:"storageType,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

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

const Default_OpReplaceBlockProto_StorageType StorageTypeProto = StorageTypeProto_DISK

func (m *OpReplaceBlockProto) GetHeader() *BaseHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *OpReplaceBlockProto) GetDelHint() string {
	if m != nil && m.DelHint != nil {
		return *m.DelHint
	}
	return ""
}

func (m *OpReplaceBlockProto) GetSource() *DatanodeInfoProto {
	if m != nil {
		return m.Source
	}
	return nil
}

func (m *OpReplaceBlockProto) GetStorageType() StorageTypeProto {
	if m != nil && m.StorageType != nil {
		return *m.StorageType
	}
	return Default_OpReplaceBlockProto_StorageType
}

type OpCopyBlockProto struct {
	Header           *BaseHeaderProto `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *OpCopyBlockProto) GetHeader() *BaseHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

type OpBlockChecksumProto struct {
	Header           *BaseHeaderProto `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *OpBlockChecksumProto) GetHeader() *BaseHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

type OpBlockGroupChecksumProto struct {
	Header    *BaseHeaderProto    `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	Datanodes *DatanodeInfosProto `protobuf:"bytes,2,req,name=datanodes" json:"datanodes,omitempty"`
	// each internal block has a block token
	BlockTokens      []*hadoop_common.TokenProto `protobuf:"bytes,3,rep,name=blockTokens" json:"blockTokens,omitempty"`
	EcPolicy         *ErasureCodingPolicyProto   `protobuf:"bytes,4,req,name=ecPolicy" json:"ecPolicy,omitempty"`
	XXX_unrecognized []byte                      `json:"-"`
}

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

func (m *OpBlockGroupChecksumProto) GetHeader() *BaseHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *OpBlockGroupChecksumProto) GetDatanodes() *DatanodeInfosProto {
	if m != nil {
		return m.Datanodes
	}
	return nil
}

func (m *OpBlockGroupChecksumProto) GetBlockTokens() []*hadoop_common.TokenProto {
	if m != nil {
		return m.BlockTokens
	}
	return nil
}

func (m *OpBlockGroupChecksumProto) GetEcPolicy() *ErasureCodingPolicyProto {
	if m != nil {
		return m.EcPolicy
	}
	return nil
}

// *
// An ID uniquely identifying a shared memory segment.
type ShortCircuitShmIdProto struct {
	Hi               *int64 `protobuf:"varint,1,req,name=hi" json:"hi,omitempty"`
	Lo               *int64 `protobuf:"varint,2,req,name=lo" json:"lo,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *ShortCircuitShmIdProto) GetHi() int64 {
	if m != nil && m.Hi != nil {
		return *m.Hi
	}
	return 0
}

func (m *ShortCircuitShmIdProto) GetLo() int64 {
	if m != nil && m.Lo != nil {
		return *m.Lo
	}
	return 0
}

// *
// An ID uniquely identifying a slot within a shared memory segment.
type ShortCircuitShmSlotProto struct {
	ShmId            *ShortCircuitShmIdProto `protobuf:"bytes,1,req,name=shmId" json:"shmId,omitempty"`
	SlotIdx          *int32                  `protobuf:"varint,2,req,name=slotIdx" json:"slotIdx,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

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

func (m *ShortCircuitShmSlotProto) GetShmId() *ShortCircuitShmIdProto {
	if m != nil {
		return m.ShmId
	}
	return nil
}

func (m *ShortCircuitShmSlotProto) GetSlotIdx() int32 {
	if m != nil && m.SlotIdx != nil {
		return *m.SlotIdx
	}
	return 0
}

type OpRequestShortCircuitAccessProto struct {
	Header *BaseHeaderProto `protobuf:"bytes,1,req,name=header" json:"header,omitempty"`
	// * In order to get short-circuit access to block data, clients must set this
	// to the highest version of the block data that they can understand.
	// Currently 1 is the only version, but more versions may exist in the future
	// if the on-disk format changes.
	MaxVersion *uint32 `protobuf:"varint,2,req,name=maxVersion" json:"maxVersion,omitempty"`
	// *
	// The shared memory slot to use, if we are using one.
	SlotId *ShortCircuitShmSlotProto `protobuf:"bytes,3,opt,name=slotId" json:"slotId,omitempty"`
	// *
	// True if the client supports verifying that the file descriptor has been
	// sent successfully.
	SupportsReceiptVerification *bool  `protobuf:"varint,4,opt,name=supportsReceiptVerification,def=0" json:"supportsReceiptVerification,omitempty"`
	XXX_unrecognized            []byte `json:"-"`
}

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

const Default_OpRequestShortCircuitAccessProto_SupportsReceiptVerification bool = false

func (m *OpRequestShortCircuitAccessProto) GetHeader() *BaseHeaderProto {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *OpRequestShortCircuitAccessProto) GetMaxVersion() uint32 {
	if m != nil && m.MaxVersion != nil {
		return *m.MaxVersion
	}
	return 0
}

func (m *OpRequestShortCircuitAccessProto) GetSlotId() *ShortCircuitShmSlotProto {
	if m != nil {
		return m.SlotId
	}
	return nil
}

func (m *OpRequestShortCircuitAccessProto) GetSupportsReceiptVerification() bool {
	if m != nil && m.SupportsReceiptVerification != nil {
		return *m.SupportsReceiptVerification
	}
	return Default_OpRequestShortCircuitAccessProto_SupportsReceiptVerification
}

type ReleaseShortCircuitAccessRequestProto struct {
	SlotId           *ShortCircuitShmSlotProto   `protobuf:"bytes,1,req,name=slotId" json:"slotId,omitempty"`
	TraceInfo        *DataTransferTraceInfoProto `protobuf:"bytes,2,opt,name=traceInfo" json:"traceInfo,omitempty"`
	XXX_unrecognized []byte                      `json:"-"`
}

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

func (m *ReleaseShortCircuitAccessRequestProto) GetSlotId() *ShortCircuitShmSlotProto {
	if m != nil {
		return m.SlotId
	}
	return nil
}

func (m *ReleaseShortCircuitAccessRequestProto) GetTraceInfo() *DataTransferTraceInfoProto {
	if m != nil {
		return m.TraceInfo
	}
	return nil
}

type ReleaseShortCircuitAccessResponseProto struct {
	Status           *Status `protobuf:"varint,1,req,name=status,enum=hadoop.hdfs.Status" json:"status,omitempty"`
	Error            *string `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *ReleaseShortCircuitAccessResponseProto) GetStatus() Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Status_SUCCESS
}

func (m *ReleaseShortCircuitAccessResponseProto) GetError() string {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ""
}

type ShortCircuitShmRequestProto struct {
	// The name of the client requesting the shared memory segment.  This is
	// purely for logging / debugging purposes.
	ClientName       *string                     `protobuf:"bytes,1,req,name=clientName" json:"clientName,omitempty"`
	TraceInfo        *DataTransferTraceInfoProto `protobuf:"bytes,2,opt,name=traceInfo" json:"traceInfo,omitempty"`
	XXX_unrecognized []byte                      `json:"-"`
}

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

func (m *ShortCircuitShmRequestProto) GetClientName() string {
	if m != nil && m.ClientName != nil {
		return *m.ClientName
	}
	return ""
}

func (m *ShortCircuitShmRequestProto) GetTraceInfo() *DataTransferTraceInfoProto {
	if m != nil {
		return m.TraceInfo
	}
	return nil
}

type ShortCircuitShmResponseProto struct {
	Status           *Status                 `protobuf:"varint,1,req,name=status,enum=hadoop.hdfs.Status" json:"status,omitempty"`
	Error            *string                 `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"`
	Id               *ShortCircuitShmIdProto `protobuf:"bytes,3,opt,name=id" json:"id,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

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

func (m *ShortCircuitShmResponseProto) GetStatus() Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Status_SUCCESS
}

func (m *ShortCircuitShmResponseProto) GetError() string {
	if m != nil && m.Error != nil {
		return *m.Error
	}
	return ""
}

func (m *ShortCircuitShmResponseProto) GetId() *ShortCircuitShmIdProto {
	if m != nil {
		return m.Id
	}
	return nil
}

type PacketHeaderProto struct {
	// All fields must be fixed-length!
	OffsetInBlock     *int64 `protobuf:"fixed64,1,req,name=offsetInBlock" json:"offsetInBlock,omitempty"`
	Seqno             *int64 `protobuf:"fixed64,2,req,name=seqno" json:"seqno,omitempty"`
	LastPacketInBlock *bool  `protobuf:"varint,3,req,name=lastPacketInBlock" json:"lastPacketInBlock,omitempty"`
	DataLen           *int32 `protobuf:"fixed32,4,req,name=dataLen" json:"dataLen,omitempty"`
	SyncBlock         *bool  `protobuf:"varint,5,opt,name=syncBlock,def=0" json:"syncBlock,omitempty"`
	XXX_unrecognized  []byte `json:"-"`
}

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

const Default_PacketHeaderProto_SyncBlock bool = false

func (m *PacketHeaderProto) GetOffsetInBlock() int64 {
	if m != nil && m.OffsetInBlock != nil {
		return *m.OffsetInBlock
	}
	return 0
}

func (m *PacketHeaderProto) GetSeqno() int64 {
	if m != nil && m.Seqno != nil {
		return *m.Seqno
	}
	return 0
}

func (m *PacketHeaderProto) GetLastPacketInBlock() bool {
	if m != nil && m.LastPacketInBlock != nil {
		return *m.LastPacketInBlock
	}
	return false
}

func (m *PacketHeaderProto) GetDataLen() int32 {
	if m != nil && m.DataLen != nil {
		return *m.DataLen
	}
	return 0
}

func (m *PacketHeaderProto) GetSyncBlock() bool {
	if m != nil && m.SyncBlock != nil {
		return *m.SyncBlock
	}
	return Default_PacketHeaderProto_SyncBlock
}

type PipelineAckProto struct {
	Seqno                  *int64   `protobuf:"zigzag64,1,req,name=seqno" json:"seqno,omitempty"`
	Reply                  []Status `protobuf:"varint,2,rep,name=reply,enum=hadoop.hdfs.Status" json:"reply,omitempty"`
	DownstreamAckTimeNanos *uint64  `protobuf:"varint,3,opt,name=downstreamAckTimeNanos,def=0" json:"downstreamAckTimeNanos,omitempty"`
	Flag                   []uint32 `protobuf:"varint,4,rep,packed,name=flag" json:"flag,omitempty"`
	XXX_unrecognized       []byte   `json:"-"`
}

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

const Default_PipelineAckProto_DownstreamAckTimeNanos uint64 = 0

func (m *PipelineAckProto) GetSeqno() int64 {
	if m != nil && m.Seqno != nil {
		return *m.Seqno
	}
	return 0
}

func (m *PipelineAckProto) GetReply() []Status {
	if m != nil {
		return m.Reply
	}
	return nil
}

func (m *PipelineAckProto) GetDownstreamAckTimeNanos() uint64 {
	if m != nil && m.DownstreamAckTimeNanos != nil {
		return *m.DownstreamAckTimeNanos
	}
	return Default_PipelineAckProto_DownstreamAckTimeNanos
}

func (m *PipelineAckProto) GetFlag() []uint32 {
	if m != nil {
		return m.Flag
	}
	return nil
}

// *
// Sent as part of the BlockOpResponseProto
// for READ_BLOCK and COPY_BLOCK operations.
type ReadOpChecksumInfoProto struct {
	Checksum *ChecksumProto `protobuf:"bytes,1,req,name=checksum" json:"checksum,omitempty"`
	// *
	// The offset into the block at which the first packet
	// will start. This is necessary since reads will align
	// backwards to a checksum chunk boundary.
	ChunkOffset      *uint64 `protobuf:"varint,2,req,name=chunkOffset" json:"chunkOffset,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *ReadOpChecksumInfoProto) Reset()                    { *m = ReadOpChecksumInfoProto{} }
func (m *ReadOpChecksumInfoProto) String() string            { return proto.CompactTextString(m) }
func (*ReadOpChecksumInfoProto) ProtoMessage()               {}
func (*ReadOpChecksumInfoProto) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{22} }

func (m *ReadOpChecksumInfoProto) GetChecksum() *ChecksumProto {
	if m != nil {
		return m.Checksum
	}
	return nil
}

func (m *ReadOpChecksumInfoProto) GetChunkOffset() uint64 {
	if m != nil && m.ChunkOffset != nil {
		return *m.ChunkOffset
	}
	return 0
}

type BlockOpResponseProto struct {
	Status             *Status                       `protobuf:"varint,1,req,name=status,enum=hadoop.hdfs.Status" json:"status,omitempty"`
	FirstBadLink       *string                       `protobuf:"bytes,2,opt,name=firstBadLink" json:"firstBadLink,omitempty"`
	ChecksumResponse   *OpBlockChecksumResponseProto `protobuf:"bytes,3,opt,name=checksumResponse" json:"checksumResponse,omitempty"`
	ReadOpChecksumInfo *ReadOpChecksumInfoProto      `protobuf:"bytes,4,opt,name=readOpChecksumInfo" json:"readOpChecksumInfo,omitempty"`
	// * explanatory text which may be useful to log on the client side
	Message *string `protobuf:"bytes,5,opt,name=message" json:"message,omitempty"`
	// * If the server chooses to agree to the request of a client for
	// short-circuit access, it will send a response message with the relevant
	// file descriptors attached.
	//
	// In the body of the message, this version number will be set to the
	// specific version number of the block data that the client is about to
	// read.
	ShortCircuitAccessVersion *uint32 `protobuf:"varint,6,opt,name=shortCircuitAccessVersion" json:"shortCircuitAccessVersion,omitempty"`
	XXX_unrecognized          []byte  `json:"-"`
}

func (m *BlockOpResponseProto) Reset()                    { *m = BlockOpResponseProto{} }
func (m *BlockOpResponseProto) String() string            { return proto.CompactTextString(m) }
func (*BlockOpResponseProto) ProtoMessage()               {}
func (*BlockOpResponseProto) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{23} }

func (m *BlockOpResponseProto) GetStatus() Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Status_SUCCESS
}

func (m *BlockOpResponseProto) GetFirstBadLink() string {
	if m != nil && m.FirstBadLink != nil {
		return *m.FirstBadLink
	}
	return ""
}

func (m *BlockOpResponseProto) GetChecksumResponse() *OpBlockChecksumResponseProto {
	if m != nil {
		return m.ChecksumResponse
	}
	return nil
}

func (m *BlockOpResponseProto) GetReadOpChecksumInfo() *ReadOpChecksumInfoProto {
	if m != nil {
		return m.ReadOpChecksumInfo
	}
	return nil
}

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

func (m *BlockOpResponseProto) GetShortCircuitAccessVersion() uint32 {
	if m != nil && m.ShortCircuitAccessVersion != nil {
		return *m.ShortCircuitAccessVersion
	}
	return 0
}

// *
// Message sent from the client to the DN after reading the entire
// read request.
type ClientReadStatusProto struct {
	Status           *Status `protobuf:"varint,1,req,name=status,enum=hadoop.hdfs.Status" json:"status,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *ClientReadStatusProto) Reset()                    { *m = ClientReadStatusProto{} }
func (m *ClientReadStatusProto) String() string            { return proto.CompactTextString(m) }
func (*ClientReadStatusProto) ProtoMessage()               {}
func (*ClientReadStatusProto) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{24} }

func (m *ClientReadStatusProto) GetStatus() Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Status_SUCCESS
}

type DNTransferAckProto struct {
	Status           *Status `protobuf:"varint,1,req,name=status,enum=hadoop.hdfs.Status" json:"status,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *DNTransferAckProto) Reset()                    { *m = DNTransferAckProto{} }
func (m *DNTransferAckProto) String() string            { return proto.CompactTextString(m) }
func (*DNTransferAckProto) ProtoMessage()               {}
func (*DNTransferAckProto) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{25} }

func (m *DNTransferAckProto) GetStatus() Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return Status_SUCCESS
}

type OpBlockChecksumResponseProto struct {
	BytesPerCrc      *uint32            `protobuf:"varint,1,req,name=bytesPerCrc" json:"bytesPerCrc,omitempty"`
	CrcPerBlock      *uint64            `protobuf:"varint,2,req,name=crcPerBlock" json:"crcPerBlock,omitempty"`
	Md5              []byte             `protobuf:"bytes,3,req,name=md5" json:"md5,omitempty"`
	CrcType          *ChecksumTypeProto `protobuf:"varint,4,opt,name=crcType,enum=hadoop.hdfs.ChecksumTypeProto" json:"crcType,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

func (m *OpBlockChecksumResponseProto) Reset()                    { *m = OpBlockChecksumResponseProto{} }
func (m *OpBlockChecksumResponseProto) String() string            { return proto.CompactTextString(m) }
func (*OpBlockChecksumResponseProto) ProtoMessage()               {}
func (*OpBlockChecksumResponseProto) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{26} }

func (m *OpBlockChecksumResponseProto) GetBytesPerCrc() uint32 {
	if m != nil && m.BytesPerCrc != nil {
		return *m.BytesPerCrc
	}
	return 0
}

func (m *OpBlockChecksumResponseProto) GetCrcPerBlock() uint64 {
	if m != nil && m.CrcPerBlock != nil {
		return *m.CrcPerBlock
	}
	return 0
}

func (m *OpBlockChecksumResponseProto) GetMd5() []byte {
	if m != nil {
		return m.Md5
	}
	return nil
}

func (m *OpBlockChecksumResponseProto) GetCrcType() ChecksumTypeProto {
	if m != nil && m.CrcType != nil {
		return *m.CrcType
	}
	return ChecksumTypeProto_CHECKSUM_NULL
}

type OpCustomProto struct {
	CustomId         *string `protobuf:"bytes,1,req,name=customId" json:"customId,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *OpCustomProto) Reset()                    { *m = OpCustomProto{} }
func (m *OpCustomProto) String() string            { return proto.CompactTextString(m) }
func (*OpCustomProto) ProtoMessage()               {}
func (*OpCustomProto) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{27} }

func (m *OpCustomProto) GetCustomId() string {
	if m != nil && m.CustomId != nil {
		return *m.CustomId
	}
	return ""
}

func init() {
	proto.RegisterType((*DataTransferEncryptorMessageProto)(nil), "hadoop.hdfs.DataTransferEncryptorMessageProto")
	proto.RegisterType((*BaseHeaderProto)(nil), "hadoop.hdfs.BaseHeaderProto")
	proto.RegisterType((*DataTransferTraceInfoProto)(nil), "hadoop.hdfs.DataTransferTraceInfoProto")
	proto.RegisterType((*ClientOperationHeaderProto)(nil), "hadoop.hdfs.ClientOperationHeaderProto")
	proto.RegisterType((*CachingStrategyProto)(nil), "hadoop.hdfs.CachingStrategyProto")
	proto.RegisterType((*OpReadBlockProto)(nil), "hadoop.hdfs.OpReadBlockProto")
	proto.RegisterType((*ChecksumProto)(nil), "hadoop.hdfs.ChecksumProto")
	proto.RegisterType((*OpWriteBlockProto)(nil), "hadoop.hdfs.OpWriteBlockProto")
	proto.RegisterType((*OpTransferBlockProto)(nil), "hadoop.hdfs.OpTransferBlockProto")
	proto.RegisterType((*OpReplaceBlockProto)(nil), "hadoop.hdfs.OpReplaceBlockProto")
	proto.RegisterType((*OpCopyBlockProto)(nil), "hadoop.hdfs.OpCopyBlockProto")
	proto.RegisterType((*OpBlockChecksumProto)(nil), "hadoop.hdfs.OpBlockChecksumProto")
	proto.RegisterType((*OpBlockGroupChecksumProto)(nil), "hadoop.hdfs.OpBlockGroupChecksumProto")
	proto.RegisterType((*ShortCircuitShmIdProto)(nil), "hadoop.hdfs.ShortCircuitShmIdProto")
	proto.RegisterType((*ShortCircuitShmSlotProto)(nil), "hadoop.hdfs.ShortCircuitShmSlotProto")
	proto.RegisterType((*OpRequestShortCircuitAccessProto)(nil), "hadoop.hdfs.OpRequestShortCircuitAccessProto")
	proto.RegisterType((*ReleaseShortCircuitAccessRequestProto)(nil), "hadoop.hdfs.ReleaseShortCircuitAccessRequestProto")
	proto.RegisterType((*ReleaseShortCircuitAccessResponseProto)(nil), "hadoop.hdfs.ReleaseShortCircuitAccessResponseProto")
	proto.RegisterType((*ShortCircuitShmRequestProto)(nil), "hadoop.hdfs.ShortCircuitShmRequestProto")
	proto.RegisterType((*ShortCircuitShmResponseProto)(nil), "hadoop.hdfs.ShortCircuitShmResponseProto")
	proto.RegisterType((*PacketHeaderProto)(nil), "hadoop.hdfs.PacketHeaderProto")
	proto.RegisterType((*PipelineAckProto)(nil), "hadoop.hdfs.PipelineAckProto")
	proto.RegisterType((*ReadOpChecksumInfoProto)(nil), "hadoop.hdfs.ReadOpChecksumInfoProto")
	proto.RegisterType((*BlockOpResponseProto)(nil), "hadoop.hdfs.BlockOpResponseProto")
	proto.RegisterType((*ClientReadStatusProto)(nil), "hadoop.hdfs.ClientReadStatusProto")
	proto.RegisterType((*DNTransferAckProto)(nil), "hadoop.hdfs.DNTransferAckProto")
	proto.RegisterType((*OpBlockChecksumResponseProto)(nil), "hadoop.hdfs.OpBlockChecksumResponseProto")
	proto.RegisterType((*OpCustomProto)(nil), "hadoop.hdfs.OpCustomProto")
	proto.RegisterEnum("hadoop.hdfs.Status", Status_name, Status_value)
	proto.RegisterEnum("hadoop.hdfs.ShortCircuitFdResponse", ShortCircuitFdResponse_name, ShortCircuitFdResponse_value)
	proto.RegisterEnum("hadoop.hdfs.DataTransferEncryptorMessageProto_DataTransferEncryptorStatus", DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_name, DataTransferEncryptorMessageProto_DataTransferEncryptorStatus_value)
	proto.RegisterEnum("hadoop.hdfs.OpWriteBlockProto_BlockConstructionStage", OpWriteBlockProto_BlockConstructionStage_name, OpWriteBlockProto_BlockConstructionStage_value)
}

func init() { proto.RegisterFile("datatransfer.proto", fileDescriptor5) }

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