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

/*
Package pb is a generated protocol buffer package.

This file contains protocol buffers that are used for Admin service.

It is generated from these files:
	Admin.proto
	Authentication.proto
	Cell.proto
	Client.proto
	ClusterId.proto
	ClusterStatus.proto
	Comparator.proto
	ErrorHandling.proto
	FS.proto
	Filter.proto
	HBase.proto
	Master.proto
	MultiRowMutation.proto
	Procedure.proto
	Quota.proto
	RPC.proto
	RegionServerStatus.proto
	Tracing.proto
	WAL.proto
	ZooKeeper.proto

It has these top-level messages:
	GetRegionInfoRequest
	GetRegionInfoResponse
	GetStoreFileRequest
	GetStoreFileResponse
	GetOnlineRegionRequest
	GetOnlineRegionResponse
	OpenRegionRequest
	OpenRegionResponse
	WarmupRegionRequest
	WarmupRegionResponse
	CloseRegionRequest
	CloseRegionResponse
	FlushRegionRequest
	FlushRegionResponse
	SplitRegionRequest
	SplitRegionResponse
	CompactRegionRequest
	CompactRegionResponse
	UpdateFavoredNodesRequest
	UpdateFavoredNodesResponse
	MergeRegionsRequest
	MergeRegionsResponse
	WALEntry
	ReplicateWALEntryRequest
	ReplicateWALEntryResponse
	RollWALWriterRequest
	RollWALWriterResponse
	StopServerRequest
	StopServerResponse
	GetServerInfoRequest
	ServerInfo
	GetServerInfoResponse
	UpdateConfigurationRequest
	UpdateConfigurationResponse
	AuthenticationKey
	TokenIdentifier
	Token
	GetAuthenticationTokenRequest
	GetAuthenticationTokenResponse
	WhoAmIRequest
	WhoAmIResponse
	Cell
	KeyValue
	Authorizations
	CellVisibility
	Column
	Get
	Result
	GetRequest
	GetResponse
	Condition
	MutationProto
	MutateRequest
	MutateResponse
	Scan
	ScanRequest
	ScanResponse
	BulkLoadHFileRequest
	BulkLoadHFileResponse
	CoprocessorServiceCall
	CoprocessorServiceResult
	CoprocessorServiceRequest
	CoprocessorServiceResponse
	Action
	RegionAction
	RegionLoadStats
	MultiRegionLoadStats
	ResultOrException
	RegionActionResult
	MultiRequest
	MultiResponse
	ClusterId
	RegionState
	RegionInTransition
	StoreSequenceId
	RegionStoreSequenceIds
	RegionLoad
	ReplicationLoadSink
	ReplicationLoadSource
	ServerLoad
	LiveServerInfo
	ClusterStatus
	Comparator
	ByteArrayComparable
	BinaryComparator
	LongComparator
	BinaryPrefixComparator
	BitComparator
	NullComparator
	RegexStringComparator
	SubstringComparator
	StackTraceElementMessage
	GenericExceptionMessage
	ForeignExceptionMessage
	HBaseVersionFileContent
	Reference
	Filter
	ColumnCountGetFilter
	ColumnPaginationFilter
	ColumnPrefixFilter
	ColumnRangeFilter
	CompareFilter
	DependentColumnFilter
	FamilyFilter
	FilterList
	FilterWrapper
	FirstKeyOnlyFilter
	FirstKeyValueMatchingQualifiersFilter
	FuzzyRowFilter
	InclusiveStopFilter
	KeyOnlyFilter
	MultipleColumnPrefixFilter
	PageFilter
	PrefixFilter
	QualifierFilter
	RandomRowFilter
	RowFilter
	SingleColumnValueExcludeFilter
	SingleColumnValueFilter
	SkipFilter
	TimestampsFilter
	ValueFilter
	WhileMatchFilter
	FilterAllFilter
	RowRange
	MultiRowRangeFilter
	TableName
	TableSchema
	ColumnFamilySchema
	RegionInfo
	FavoredNodes
	RegionSpecifier
	TimeRange
	ColumnFamilyTimeRange
	ServerName
	Coprocessor
	NameStringPair
	NameBytesPair
	BytesBytesPair
	NameInt64Pair
	SnapshotDescription
	ProcedureDescription
	EmptyMsg
	LongMsg
	DoubleMsg
	BigDecimalMsg
	UUID
	NamespaceDescriptor
	VersionInfo
	RegionServerInfo
	AddColumnRequest
	AddColumnResponse
	DeleteColumnRequest
	DeleteColumnResponse
	ModifyColumnRequest
	ModifyColumnResponse
	MoveRegionRequest
	MoveRegionResponse
	DispatchMergingRegionsRequest
	DispatchMergingRegionsResponse
	AssignRegionRequest
	AssignRegionResponse
	UnassignRegionRequest
	UnassignRegionResponse
	OfflineRegionRequest
	OfflineRegionResponse
	CreateTableRequest
	CreateTableResponse
	DeleteTableRequest
	DeleteTableResponse
	TruncateTableRequest
	TruncateTableResponse
	EnableTableRequest
	EnableTableResponse
	DisableTableRequest
	DisableTableResponse
	ModifyTableRequest
	ModifyTableResponse
	CreateNamespaceRequest
	CreateNamespaceResponse
	DeleteNamespaceRequest
	DeleteNamespaceResponse
	ModifyNamespaceRequest
	ModifyNamespaceResponse
	GetNamespaceDescriptorRequest
	GetNamespaceDescriptorResponse
	ListNamespaceDescriptorsRequest
	ListNamespaceDescriptorsResponse
	ListTableDescriptorsByNamespaceRequest
	ListTableDescriptorsByNamespaceResponse
	ListTableNamesByNamespaceRequest
	ListTableNamesByNamespaceResponse
	ShutdownRequest
	ShutdownResponse
	StopMasterRequest
	StopMasterResponse
	BalanceRequest
	BalanceResponse
	SetBalancerRunningRequest
	SetBalancerRunningResponse
	IsBalancerEnabledRequest
	IsBalancerEnabledResponse
	SetSplitOrMergeEnabledRequest
	SetSplitOrMergeEnabledResponse
	IsSplitOrMergeEnabledRequest
	IsSplitOrMergeEnabledResponse
	NormalizeRequest
	NormalizeResponse
	SetNormalizerRunningRequest
	SetNormalizerRunningResponse
	IsNormalizerEnabledRequest
	IsNormalizerEnabledResponse
	RunCatalogScanRequest
	RunCatalogScanResponse
	EnableCatalogJanitorRequest
	EnableCatalogJanitorResponse
	IsCatalogJanitorEnabledRequest
	IsCatalogJanitorEnabledResponse
	SnapshotRequest
	SnapshotResponse
	GetCompletedSnapshotsRequest
	GetCompletedSnapshotsResponse
	DeleteSnapshotRequest
	DeleteSnapshotResponse
	RestoreSnapshotRequest
	RestoreSnapshotResponse
	IsSnapshotDoneRequest
	IsSnapshotDoneResponse
	IsRestoreSnapshotDoneRequest
	IsRestoreSnapshotDoneResponse
	GetSchemaAlterStatusRequest
	GetSchemaAlterStatusResponse
	GetTableDescriptorsRequest
	GetTableDescriptorsResponse
	GetTableNamesRequest
	GetTableNamesResponse
	GetClusterStatusRequest
	GetClusterStatusResponse
	IsMasterRunningRequest
	IsMasterRunningResponse
	ExecProcedureRequest
	ExecProcedureResponse
	IsProcedureDoneRequest
	IsProcedureDoneResponse
	GetProcedureResultRequest
	GetProcedureResultResponse
	AbortProcedureRequest
	AbortProcedureResponse
	ListProceduresRequest
	ListProceduresResponse
	SetQuotaRequest
	SetQuotaResponse
	MajorCompactionTimestampRequest
	MajorCompactionTimestampForRegionRequest
	MajorCompactionTimestampResponse
	SecurityCapabilitiesRequest
	SecurityCapabilitiesResponse
	MultiRowMutationProcessorRequest
	MultiRowMutationProcessorResponse
	MutateRowsRequest
	MutateRowsResponse
	Procedure
	SequentialProcedureData
	StateMachineProcedureData
	ProcedureWALHeader
	ProcedureWALTrailer
	ProcedureStoreTracker
	ProcedureWALEntry
	TimedQuota
	Throttle
	ThrottleRequest
	Quotas
	QuotaUsage
	UserInformation
	ConnectionHeader
	CellBlockMeta
	ExceptionResponse
	RequestHeader
	ResponseHeader
	RegionServerStartupRequest
	RegionServerStartupResponse
	RegionServerReportRequest
	RegionServerReportResponse
	ReportRSFatalErrorRequest
	ReportRSFatalErrorResponse
	GetLastFlushedSequenceIdRequest
	GetLastFlushedSequenceIdResponse
	RegionStateTransition
	ReportRegionStateTransitionRequest
	ReportRegionStateTransitionResponse
	RPCTInfo
	WALHeader
	WALKey
	FamilyScope
	CompactionDescriptor
	FlushDescriptor
	StoreDescriptor
	BulkLoadDescriptor
	RegionEventDescriptor
	WALTrailer
	MetaRegionServer
	Master
	ClusterUp
	RegionTransition
	SplitLogTask
	Table
	ReplicationPeer
	ReplicationState
	ReplicationHLogPosition
	ReplicationLock
	TableLock
	SwitchState
*/
package pb

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

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

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

type GetRegionInfoResponse_CompactionState int32

const (
	GetRegionInfoResponse_NONE            GetRegionInfoResponse_CompactionState = 0
	GetRegionInfoResponse_MINOR           GetRegionInfoResponse_CompactionState = 1
	GetRegionInfoResponse_MAJOR           GetRegionInfoResponse_CompactionState = 2
	GetRegionInfoResponse_MAJOR_AND_MINOR GetRegionInfoResponse_CompactionState = 3
)

var GetRegionInfoResponse_CompactionState_name = map[int32]string{
	0: "NONE",
	1: "MINOR",
	2: "MAJOR",
	3: "MAJOR_AND_MINOR",
}
var GetRegionInfoResponse_CompactionState_value = map[string]int32{
	"NONE":            0,
	"MINOR":           1,
	"MAJOR":           2,
	"MAJOR_AND_MINOR": 3,
}

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

type OpenRegionResponse_RegionOpeningState int32

const (
	OpenRegionResponse_OPENED         OpenRegionResponse_RegionOpeningState = 0
	OpenRegionResponse_ALREADY_OPENED OpenRegionResponse_RegionOpeningState = 1
	OpenRegionResponse_FAILED_OPENING OpenRegionResponse_RegionOpeningState = 2
)

var OpenRegionResponse_RegionOpeningState_name = map[int32]string{
	0: "OPENED",
	1: "ALREADY_OPENED",
	2: "FAILED_OPENING",
}
var OpenRegionResponse_RegionOpeningState_value = map[string]int32{
	"OPENED":         0,
	"ALREADY_OPENED": 1,
	"FAILED_OPENING": 2,
}

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

type GetRegionInfoRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	CompactionState  *bool            `protobuf:"varint,2,opt,name=compaction_state,json=compactionState" json:"compaction_state,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *GetRegionInfoRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *GetRegionInfoRequest) GetCompactionState() bool {
	if m != nil && m.CompactionState != nil {
		return *m.CompactionState
	}
	return false
}

type GetRegionInfoResponse struct {
	RegionInfo       *RegionInfo                            `protobuf:"bytes,1,req,name=region_info,json=regionInfo" json:"region_info,omitempty"`
	CompactionState  *GetRegionInfoResponse_CompactionState `protobuf:"varint,2,opt,name=compaction_state,json=compactionState,enum=pb.GetRegionInfoResponse_CompactionState" json:"compaction_state,omitempty"`
	IsRecovering     *bool                                  `protobuf:"varint,3,opt,name=isRecovering" json:"isRecovering,omitempty"`
	XXX_unrecognized []byte                                 `json:"-"`
}

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

func (m *GetRegionInfoResponse) GetRegionInfo() *RegionInfo {
	if m != nil {
		return m.RegionInfo
	}
	return nil
}

func (m *GetRegionInfoResponse) GetCompactionState() GetRegionInfoResponse_CompactionState {
	if m != nil && m.CompactionState != nil {
		return *m.CompactionState
	}
	return GetRegionInfoResponse_NONE
}

func (m *GetRegionInfoResponse) GetIsRecovering() bool {
	if m != nil && m.IsRecovering != nil {
		return *m.IsRecovering
	}
	return false
}

// *
// Get a list of store files for a set of column families in a particular region.
// If no column family is specified, get the store files for all column families.
type GetStoreFileRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Family           [][]byte         `protobuf:"bytes,2,rep,name=family" json:"family,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *GetStoreFileRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *GetStoreFileRequest) GetFamily() [][]byte {
	if m != nil {
		return m.Family
	}
	return nil
}

type GetStoreFileResponse struct {
	StoreFile        []string `protobuf:"bytes,1,rep,name=store_file,json=storeFile" json:"store_file,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *GetStoreFileResponse) GetStoreFile() []string {
	if m != nil {
		return m.StoreFile
	}
	return nil
}

type GetOnlineRegionRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type GetOnlineRegionResponse struct {
	RegionInfo       []*RegionInfo `protobuf:"bytes,1,rep,name=region_info,json=regionInfo" json:"region_info,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

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

func (m *GetOnlineRegionResponse) GetRegionInfo() []*RegionInfo {
	if m != nil {
		return m.RegionInfo
	}
	return nil
}

type OpenRegionRequest struct {
	OpenInfo []*OpenRegionRequest_RegionOpenInfo `protobuf:"bytes,1,rep,name=open_info,json=openInfo" json:"open_info,omitempty"`
	// the intended server for this RPC.
	ServerStartCode *uint64 `protobuf:"varint,2,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
	// wall clock time from master
	MasterSystemTime *uint64 `protobuf:"varint,5,opt,name=master_system_time,json=masterSystemTime" json:"master_system_time,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *OpenRegionRequest) GetOpenInfo() []*OpenRegionRequest_RegionOpenInfo {
	if m != nil {
		return m.OpenInfo
	}
	return nil
}

func (m *OpenRegionRequest) GetServerStartCode() uint64 {
	if m != nil && m.ServerStartCode != nil {
		return *m.ServerStartCode
	}
	return 0
}

func (m *OpenRegionRequest) GetMasterSystemTime() uint64 {
	if m != nil && m.MasterSystemTime != nil {
		return *m.MasterSystemTime
	}
	return 0
}

type OpenRegionRequest_RegionOpenInfo struct {
	Region               *RegionInfo   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	VersionOfOfflineNode *uint32       `protobuf:"varint,2,opt,name=version_of_offline_node,json=versionOfOfflineNode" json:"version_of_offline_node,omitempty"`
	FavoredNodes         []*ServerName `protobuf:"bytes,3,rep,name=favored_nodes,json=favoredNodes" json:"favored_nodes,omitempty"`
	// open region for distributedLogReplay
	OpenForDistributedLogReplay *bool  `protobuf:"varint,4,opt,name=openForDistributedLogReplay" json:"openForDistributedLogReplay,omitempty"`
	XXX_unrecognized            []byte `json:"-"`
}

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

func (m *OpenRegionRequest_RegionOpenInfo) GetRegion() *RegionInfo {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *OpenRegionRequest_RegionOpenInfo) GetVersionOfOfflineNode() uint32 {
	if m != nil && m.VersionOfOfflineNode != nil {
		return *m.VersionOfOfflineNode
	}
	return 0
}

func (m *OpenRegionRequest_RegionOpenInfo) GetFavoredNodes() []*ServerName {
	if m != nil {
		return m.FavoredNodes
	}
	return nil
}

func (m *OpenRegionRequest_RegionOpenInfo) GetOpenForDistributedLogReplay() bool {
	if m != nil && m.OpenForDistributedLogReplay != nil {
		return *m.OpenForDistributedLogReplay
	}
	return false
}

type OpenRegionResponse struct {
	OpeningState     []OpenRegionResponse_RegionOpeningState `protobuf:"varint,1,rep,name=opening_state,json=openingState,enum=pb.OpenRegionResponse_RegionOpeningState" json:"opening_state,omitempty"`
	XXX_unrecognized []byte                                  `json:"-"`
}

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

func (m *OpenRegionResponse) GetOpeningState() []OpenRegionResponse_RegionOpeningState {
	if m != nil {
		return m.OpeningState
	}
	return nil
}

type WarmupRegionRequest struct {
	RegionInfo       *RegionInfo `protobuf:"bytes,1,req,name=regionInfo" json:"regionInfo,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

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

func (m *WarmupRegionRequest) GetRegionInfo() *RegionInfo {
	if m != nil {
		return m.RegionInfo
	}
	return nil
}

type WarmupRegionResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

// *
// Closes the specified region and will use or not use ZK during the close
// according to the specified flag.
type CloseRegionRequest struct {
	Region               *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	VersionOfClosingNode *uint32          `protobuf:"varint,2,opt,name=version_of_closing_node,json=versionOfClosingNode" json:"version_of_closing_node,omitempty"`
	TransitionIn_ZK      *bool            `protobuf:"varint,3,opt,name=transition_in_ZK,json=transitionInZK,def=1" json:"transition_in_ZK,omitempty"`
	DestinationServer    *ServerName      `protobuf:"bytes,4,opt,name=destination_server,json=destinationServer" json:"destination_server,omitempty"`
	// the intended server for this RPC.
	ServerStartCode  *uint64 `protobuf:"varint,5,opt,name=serverStartCode" json:"serverStartCode,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

const Default_CloseRegionRequest_TransitionIn_ZK bool = true

func (m *CloseRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *CloseRegionRequest) GetVersionOfClosingNode() uint32 {
	if m != nil && m.VersionOfClosingNode != nil {
		return *m.VersionOfClosingNode
	}
	return 0
}

func (m *CloseRegionRequest) GetTransitionIn_ZK() bool {
	if m != nil && m.TransitionIn_ZK != nil {
		return *m.TransitionIn_ZK
	}
	return Default_CloseRegionRequest_TransitionIn_ZK
}

func (m *CloseRegionRequest) GetDestinationServer() *ServerName {
	if m != nil {
		return m.DestinationServer
	}
	return nil
}

func (m *CloseRegionRequest) GetServerStartCode() uint64 {
	if m != nil && m.ServerStartCode != nil {
		return *m.ServerStartCode
	}
	return 0
}

type CloseRegionResponse struct {
	Closed           *bool  `protobuf:"varint,1,req,name=closed" json:"closed,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *CloseRegionResponse) GetClosed() bool {
	if m != nil && m.Closed != nil {
		return *m.Closed
	}
	return false
}

// *
// Flushes the MemStore of the specified region.
// <p>
// This method is synchronous.
type FlushRegionRequest struct {
	Region              *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	IfOlderThanTs       *uint64          `protobuf:"varint,2,opt,name=if_older_than_ts,json=ifOlderThanTs" json:"if_older_than_ts,omitempty"`
	WriteFlushWalMarker *bool            `protobuf:"varint,3,opt,name=write_flush_wal_marker,json=writeFlushWalMarker" json:"write_flush_wal_marker,omitempty"`
	XXX_unrecognized    []byte           `json:"-"`
}

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

func (m *FlushRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *FlushRegionRequest) GetIfOlderThanTs() uint64 {
	if m != nil && m.IfOlderThanTs != nil {
		return *m.IfOlderThanTs
	}
	return 0
}

func (m *FlushRegionRequest) GetWriteFlushWalMarker() bool {
	if m != nil && m.WriteFlushWalMarker != nil {
		return *m.WriteFlushWalMarker
	}
	return false
}

type FlushRegionResponse struct {
	LastFlushTime       *uint64 `protobuf:"varint,1,req,name=last_flush_time,json=lastFlushTime" json:"last_flush_time,omitempty"`
	Flushed             *bool   `protobuf:"varint,2,opt,name=flushed" json:"flushed,omitempty"`
	WroteFlushWalMarker *bool   `protobuf:"varint,3,opt,name=wrote_flush_wal_marker,json=wroteFlushWalMarker" json:"wrote_flush_wal_marker,omitempty"`
	XXX_unrecognized    []byte  `json:"-"`
}

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

func (m *FlushRegionResponse) GetLastFlushTime() uint64 {
	if m != nil && m.LastFlushTime != nil {
		return *m.LastFlushTime
	}
	return 0
}

func (m *FlushRegionResponse) GetFlushed() bool {
	if m != nil && m.Flushed != nil {
		return *m.Flushed
	}
	return false
}

func (m *FlushRegionResponse) GetWroteFlushWalMarker() bool {
	if m != nil && m.WroteFlushWalMarker != nil {
		return *m.WroteFlushWalMarker
	}
	return false
}

// *
// Splits the specified region.
// <p>
// This method currently flushes the region and then forces a compaction which
// will then trigger a split.  The flush is done synchronously but the
// compaction is asynchronous.
type SplitRegionRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	SplitPoint       []byte           `protobuf:"bytes,2,opt,name=split_point,json=splitPoint" json:"split_point,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *SplitRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *SplitRegionRequest) GetSplitPoint() []byte {
	if m != nil {
		return m.SplitPoint
	}
	return nil
}

type SplitRegionResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

// *
// Compacts the specified region.  Performs a major compaction if specified.
// <p>
// This method is asynchronous.
type CompactRegionRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Major            *bool            `protobuf:"varint,2,opt,name=major" json:"major,omitempty"`
	Family           []byte           `protobuf:"bytes,3,opt,name=family" json:"family,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *CompactRegionRequest) GetRegion() *RegionSpecifier {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *CompactRegionRequest) GetMajor() bool {
	if m != nil && m.Major != nil {
		return *m.Major
	}
	return false
}

func (m *CompactRegionRequest) GetFamily() []byte {
	if m != nil {
		return m.Family
	}
	return nil
}

type CompactRegionResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type UpdateFavoredNodesRequest struct {
	UpdateInfo       []*UpdateFavoredNodesRequest_RegionUpdateInfo `protobuf:"bytes,1,rep,name=update_info,json=updateInfo" json:"update_info,omitempty"`
	XXX_unrecognized []byte                                        `json:"-"`
}

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

func (m *UpdateFavoredNodesRequest) GetUpdateInfo() []*UpdateFavoredNodesRequest_RegionUpdateInfo {
	if m != nil {
		return m.UpdateInfo
	}
	return nil
}

type UpdateFavoredNodesRequest_RegionUpdateInfo struct {
	Region           *RegionInfo   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	FavoredNodes     []*ServerName `protobuf:"bytes,2,rep,name=favored_nodes,json=favoredNodes" json:"favored_nodes,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

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

func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetRegion() *RegionInfo {
	if m != nil {
		return m.Region
	}
	return nil
}

func (m *UpdateFavoredNodesRequest_RegionUpdateInfo) GetFavoredNodes() []*ServerName {
	if m != nil {
		return m.FavoredNodes
	}
	return nil
}

type UpdateFavoredNodesResponse struct {
	Response         *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *UpdateFavoredNodesResponse) GetResponse() uint32 {
	if m != nil && m.Response != nil {
		return *m.Response
	}
	return 0
}

// *
// Merges the specified regions.
// <p>
// This method currently closes the regions and then merges them
type MergeRegionsRequest struct {
	RegionA  *RegionSpecifier `protobuf:"bytes,1,req,name=region_a,json=regionA" json:"region_a,omitempty"`
	RegionB  *RegionSpecifier `protobuf:"bytes,2,req,name=region_b,json=regionB" json:"region_b,omitempty"`
	Forcible *bool            `protobuf:"varint,3,opt,name=forcible,def=0" json:"forcible,omitempty"`
	// wall clock time from master
	MasterSystemTime *uint64 `protobuf:"varint,4,opt,name=master_system_time,json=masterSystemTime" json:"master_system_time,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

const Default_MergeRegionsRequest_Forcible bool = false

func (m *MergeRegionsRequest) GetRegionA() *RegionSpecifier {
	if m != nil {
		return m.RegionA
	}
	return nil
}

func (m *MergeRegionsRequest) GetRegionB() *RegionSpecifier {
	if m != nil {
		return m.RegionB
	}
	return nil
}

func (m *MergeRegionsRequest) GetForcible() bool {
	if m != nil && m.Forcible != nil {
		return *m.Forcible
	}
	return Default_MergeRegionsRequest_Forcible
}

func (m *MergeRegionsRequest) GetMasterSystemTime() uint64 {
	if m != nil && m.MasterSystemTime != nil {
		return *m.MasterSystemTime
	}
	return 0
}

type MergeRegionsResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

// Protocol buffer version of WAL for replication
type WALEntry struct {
	Key *WALKey `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
	// Following may be null if the KVs/Cells are carried along the side in a cellblock (See
	// RPC for more on cellblocks). If Cells/KVs are in a cellblock, this next field is null
	// and associated_cell_count has count of Cells associated w/ this WALEntry
	KeyValueBytes [][]byte `protobuf:"bytes,2,rep,name=key_value_bytes,json=keyValueBytes" json:"key_value_bytes,omitempty"`
	// If Cell data is carried alongside in a cellblock, this is count of Cells in the cellblock.
	AssociatedCellCount *int32 `protobuf:"varint,3,opt,name=associated_cell_count,json=associatedCellCount" json:"associated_cell_count,omitempty"`
	XXX_unrecognized    []byte `json:"-"`
}

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

func (m *WALEntry) GetKey() *WALKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *WALEntry) GetKeyValueBytes() [][]byte {
	if m != nil {
		return m.KeyValueBytes
	}
	return nil
}

func (m *WALEntry) GetAssociatedCellCount() int32 {
	if m != nil && m.AssociatedCellCount != nil {
		return *m.AssociatedCellCount
	}
	return 0
}

// *
// Replicates the given entries. The guarantee is that the given entries
// will be durable on the slave cluster if this method returns without
// any exception.  hbase.replication has to be set to true for this to work.
type ReplicateWALEntryRequest struct {
	Entry                      []*WALEntry `protobuf:"bytes,1,rep,name=entry" json:"entry,omitempty"`
	ReplicationClusterId       *string     `protobuf:"bytes,2,opt,name=replicationClusterId" json:"replicationClusterId,omitempty"`
	SourceBaseNamespaceDirPath *string     `protobuf:"bytes,3,opt,name=sourceBaseNamespaceDirPath" json:"sourceBaseNamespaceDirPath,omitempty"`
	SourceHFileArchiveDirPath  *string     `protobuf:"bytes,4,opt,name=sourceHFileArchiveDirPath" json:"sourceHFileArchiveDirPath,omitempty"`
	XXX_unrecognized           []byte      `json:"-"`
}

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

func (m *ReplicateWALEntryRequest) GetEntry() []*WALEntry {
	if m != nil {
		return m.Entry
	}
	return nil
}

func (m *ReplicateWALEntryRequest) GetReplicationClusterId() string {
	if m != nil && m.ReplicationClusterId != nil {
		return *m.ReplicationClusterId
	}
	return ""
}

func (m *ReplicateWALEntryRequest) GetSourceBaseNamespaceDirPath() string {
	if m != nil && m.SourceBaseNamespaceDirPath != nil {
		return *m.SourceBaseNamespaceDirPath
	}
	return ""
}

func (m *ReplicateWALEntryRequest) GetSourceHFileArchiveDirPath() string {
	if m != nil && m.SourceHFileArchiveDirPath != nil {
		return *m.SourceHFileArchiveDirPath
	}
	return ""
}

type ReplicateWALEntryResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type RollWALWriterRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

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

//
// Roll request responses no longer include regions to flush
// this list will always be empty when talking to a 1.0 server
type RollWALWriterResponse struct {
	// A list of encoded name of regions to flush
	RegionToFlush    [][]byte `protobuf:"bytes,1,rep,name=region_to_flush,json=regionToFlush" json:"region_to_flush,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *RollWALWriterResponse) GetRegionToFlush() [][]byte {
	if m != nil {
		return m.RegionToFlush
	}
	return nil
}

type StopServerRequest struct {
	Reason           *string `protobuf:"bytes,1,req,name=reason" json:"reason,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *StopServerRequest) GetReason() string {
	if m != nil && m.Reason != nil {
		return *m.Reason
	}
	return ""
}

type StopServerResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *StopServerResponse) Reset()                    { *m = StopServerResponse{} }
func (m *StopServerResponse) String() string            { return proto.CompactTextString(m) }
func (*StopServerResponse) ProtoMessage()               {}
func (*StopServerResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }

type GetServerInfoRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *GetServerInfoRequest) Reset()                    { *m = GetServerInfoRequest{} }
func (m *GetServerInfoRequest) String() string            { return proto.CompactTextString(m) }
func (*GetServerInfoRequest) ProtoMessage()               {}
func (*GetServerInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }

type ServerInfo struct {
	ServerName       *ServerName `protobuf:"bytes,1,req,name=server_name,json=serverName" json:"server_name,omitempty"`
	WebuiPort        *uint32     `protobuf:"varint,2,opt,name=webui_port,json=webuiPort" json:"webui_port,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *ServerInfo) Reset()                    { *m = ServerInfo{} }
func (m *ServerInfo) String() string            { return proto.CompactTextString(m) }
func (*ServerInfo) ProtoMessage()               {}
func (*ServerInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }

func (m *ServerInfo) GetServerName() *ServerName {
	if m != nil {
		return m.ServerName
	}
	return nil
}

func (m *ServerInfo) GetWebuiPort() uint32 {
	if m != nil && m.WebuiPort != nil {
		return *m.WebuiPort
	}
	return 0
}

type GetServerInfoResponse struct {
	ServerInfo       *ServerInfo `protobuf:"bytes,1,req,name=server_info,json=serverInfo" json:"server_info,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *GetServerInfoResponse) Reset()                    { *m = GetServerInfoResponse{} }
func (m *GetServerInfoResponse) String() string            { return proto.CompactTextString(m) }
func (*GetServerInfoResponse) ProtoMessage()               {}
func (*GetServerInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }

func (m *GetServerInfoResponse) GetServerInfo() *ServerInfo {
	if m != nil {
		return m.ServerInfo
	}
	return nil
}

type UpdateConfigurationRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *UpdateConfigurationRequest) Reset()                    { *m = UpdateConfigurationRequest{} }
func (m *UpdateConfigurationRequest) String() string            { return proto.CompactTextString(m) }
func (*UpdateConfigurationRequest) ProtoMessage()               {}
func (*UpdateConfigurationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }

type UpdateConfigurationResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *UpdateConfigurationResponse) Reset()                    { *m = UpdateConfigurationResponse{} }
func (m *UpdateConfigurationResponse) String() string            { return proto.CompactTextString(m) }
func (*UpdateConfigurationResponse) ProtoMessage()               {}
func (*UpdateConfigurationResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }

func init() {
	proto.RegisterType((*GetRegionInfoRequest)(nil), "pb.GetRegionInfoRequest")
	proto.RegisterType((*GetRegionInfoResponse)(nil), "pb.GetRegionInfoResponse")
	proto.RegisterType((*GetStoreFileRequest)(nil), "pb.GetStoreFileRequest")
	proto.RegisterType((*GetStoreFileResponse)(nil), "pb.GetStoreFileResponse")
	proto.RegisterType((*GetOnlineRegionRequest)(nil), "pb.GetOnlineRegionRequest")
	proto.RegisterType((*GetOnlineRegionResponse)(nil), "pb.GetOnlineRegionResponse")
	proto.RegisterType((*OpenRegionRequest)(nil), "pb.OpenRegionRequest")
	proto.RegisterType((*OpenRegionRequest_RegionOpenInfo)(nil), "pb.OpenRegionRequest.RegionOpenInfo")
	proto.RegisterType((*OpenRegionResponse)(nil), "pb.OpenRegionResponse")
	proto.RegisterType((*WarmupRegionRequest)(nil), "pb.WarmupRegionRequest")
	proto.RegisterType((*WarmupRegionResponse)(nil), "pb.WarmupRegionResponse")
	proto.RegisterType((*CloseRegionRequest)(nil), "pb.CloseRegionRequest")
	proto.RegisterType((*CloseRegionResponse)(nil), "pb.CloseRegionResponse")
	proto.RegisterType((*FlushRegionRequest)(nil), "pb.FlushRegionRequest")
	proto.RegisterType((*FlushRegionResponse)(nil), "pb.FlushRegionResponse")
	proto.RegisterType((*SplitRegionRequest)(nil), "pb.SplitRegionRequest")
	proto.RegisterType((*SplitRegionResponse)(nil), "pb.SplitRegionResponse")
	proto.RegisterType((*CompactRegionRequest)(nil), "pb.CompactRegionRequest")
	proto.RegisterType((*CompactRegionResponse)(nil), "pb.CompactRegionResponse")
	proto.RegisterType((*UpdateFavoredNodesRequest)(nil), "pb.UpdateFavoredNodesRequest")
	proto.RegisterType((*UpdateFavoredNodesRequest_RegionUpdateInfo)(nil), "pb.UpdateFavoredNodesRequest.RegionUpdateInfo")
	proto.RegisterType((*UpdateFavoredNodesResponse)(nil), "pb.UpdateFavoredNodesResponse")
	proto.RegisterType((*MergeRegionsRequest)(nil), "pb.MergeRegionsRequest")
	proto.RegisterType((*MergeRegionsResponse)(nil), "pb.MergeRegionsResponse")
	proto.RegisterType((*WALEntry)(nil), "pb.WALEntry")
	proto.RegisterType((*ReplicateWALEntryRequest)(nil), "pb.ReplicateWALEntryRequest")
	proto.RegisterType((*ReplicateWALEntryResponse)(nil), "pb.ReplicateWALEntryResponse")
	proto.RegisterType((*RollWALWriterRequest)(nil), "pb.RollWALWriterRequest")
	proto.RegisterType((*RollWALWriterResponse)(nil), "pb.RollWALWriterResponse")
	proto.RegisterType((*StopServerRequest)(nil), "pb.StopServerRequest")
	proto.RegisterType((*StopServerResponse)(nil), "pb.StopServerResponse")
	proto.RegisterType((*GetServerInfoRequest)(nil), "pb.GetServerInfoRequest")
	proto.RegisterType((*ServerInfo)(nil), "pb.ServerInfo")
	proto.RegisterType((*GetServerInfoResponse)(nil), "pb.GetServerInfoResponse")
	proto.RegisterType((*UpdateConfigurationRequest)(nil), "pb.UpdateConfigurationRequest")
	proto.RegisterType((*UpdateConfigurationResponse)(nil), "pb.UpdateConfigurationResponse")
	proto.RegisterEnum("pb.GetRegionInfoResponse_CompactionState", GetRegionInfoResponse_CompactionState_name, GetRegionInfoResponse_CompactionState_value)
	proto.RegisterEnum("pb.OpenRegionResponse_RegionOpeningState", OpenRegionResponse_RegionOpeningState_name, OpenRegionResponse_RegionOpeningState_value)
}

func init() { proto.RegisterFile("Admin.proto", fileDescriptor0) }

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