openbilibili/vendor/github.com/tsuna/gohbase/pb/HBase.pb.go

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

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

// Comparison operators
type CompareType int32

const (
	CompareType_LESS             CompareType = 0
	CompareType_LESS_OR_EQUAL    CompareType = 1
	CompareType_EQUAL            CompareType = 2
	CompareType_NOT_EQUAL        CompareType = 3
	CompareType_GREATER_OR_EQUAL CompareType = 4
	CompareType_GREATER          CompareType = 5
	CompareType_NO_OP            CompareType = 6
)

var CompareType_name = map[int32]string{
	0: "LESS",
	1: "LESS_OR_EQUAL",
	2: "EQUAL",
	3: "NOT_EQUAL",
	4: "GREATER_OR_EQUAL",
	5: "GREATER",
	6: "NO_OP",
}
var CompareType_value = map[string]int32{
	"LESS":             0,
	"LESS_OR_EQUAL":    1,
	"EQUAL":            2,
	"NOT_EQUAL":        3,
	"GREATER_OR_EQUAL": 4,
	"GREATER":          5,
	"NO_OP":            6,
}

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

type TimeUnit int32

const (
	TimeUnit_NANOSECONDS  TimeUnit = 1
	TimeUnit_MICROSECONDS TimeUnit = 2
	TimeUnit_MILLISECONDS TimeUnit = 3
	TimeUnit_SECONDS      TimeUnit = 4
	TimeUnit_MINUTES      TimeUnit = 5
	TimeUnit_HOURS        TimeUnit = 6
	TimeUnit_DAYS         TimeUnit = 7
)

var TimeUnit_name = map[int32]string{
	1: "NANOSECONDS",
	2: "MICROSECONDS",
	3: "MILLISECONDS",
	4: "SECONDS",
	5: "MINUTES",
	6: "HOURS",
	7: "DAYS",
}
var TimeUnit_value = map[string]int32{
	"NANOSECONDS":  1,
	"MICROSECONDS": 2,
	"MILLISECONDS": 3,
	"SECONDS":      4,
	"MINUTES":      5,
	"HOURS":        6,
	"DAYS":         7,
}

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

type RegionSpecifier_RegionSpecifierType int32

const (
	// <tablename>,<startkey>,<regionId>.<encodedName>
	RegionSpecifier_REGION_NAME RegionSpecifier_RegionSpecifierType = 1
	// hash of <tablename>,<startkey>,<regionId>
	RegionSpecifier_ENCODED_REGION_NAME RegionSpecifier_RegionSpecifierType = 2
)

var RegionSpecifier_RegionSpecifierType_name = map[int32]string{
	1: "REGION_NAME",
	2: "ENCODED_REGION_NAME",
}
var RegionSpecifier_RegionSpecifierType_value = map[string]int32{
	"REGION_NAME":         1,
	"ENCODED_REGION_NAME": 2,
}

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

type SnapshotDescription_Type int32

const (
	SnapshotDescription_DISABLED  SnapshotDescription_Type = 0
	SnapshotDescription_FLUSH     SnapshotDescription_Type = 1
	SnapshotDescription_SKIPFLUSH SnapshotDescription_Type = 2
)

var SnapshotDescription_Type_name = map[int32]string{
	0: "DISABLED",
	1: "FLUSH",
	2: "SKIPFLUSH",
}
var SnapshotDescription_Type_value = map[string]int32{
	"DISABLED":  0,
	"FLUSH":     1,
	"SKIPFLUSH": 2,
}

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

// *
// Table Name
type TableName struct {
	Namespace        []byte `protobuf:"bytes,1,req,name=namespace" json:"namespace,omitempty"`
	Qualifier        []byte `protobuf:"bytes,2,req,name=qualifier" json:"qualifier,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *TableName) GetNamespace() []byte {
	if m != nil {
		return m.Namespace
	}
	return nil
}

func (m *TableName) GetQualifier() []byte {
	if m != nil {
		return m.Qualifier
	}
	return nil
}

// *
// Table Schema
// Inspired by the rest TableSchema
type TableSchema struct {
	TableName        *TableName            `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	Attributes       []*BytesBytesPair     `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty"`
	ColumnFamilies   []*ColumnFamilySchema `protobuf:"bytes,3,rep,name=column_families,json=columnFamilies" json:"column_families,omitempty"`
	Configuration    []*NameStringPair     `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
	XXX_unrecognized []byte                `json:"-"`
}

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

func (m *TableSchema) GetTableName() *TableName {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *TableSchema) GetAttributes() []*BytesBytesPair {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *TableSchema) GetColumnFamilies() []*ColumnFamilySchema {
	if m != nil {
		return m.ColumnFamilies
	}
	return nil
}

func (m *TableSchema) GetConfiguration() []*NameStringPair {
	if m != nil {
		return m.Configuration
	}
	return nil
}

// *
// Column Family Schema
// Inspired by the rest ColumSchemaMessage
type ColumnFamilySchema struct {
	Name             []byte            `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Attributes       []*BytesBytesPair `protobuf:"bytes,2,rep,name=attributes" json:"attributes,omitempty"`
	Configuration    []*NameStringPair `protobuf:"bytes,3,rep,name=configuration" json:"configuration,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

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

func (m *ColumnFamilySchema) GetName() []byte {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *ColumnFamilySchema) GetAttributes() []*BytesBytesPair {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *ColumnFamilySchema) GetConfiguration() []*NameStringPair {
	if m != nil {
		return m.Configuration
	}
	return nil
}

// *
// Protocol buffer version of HRegionInfo.
type RegionInfo struct {
	RegionId         *uint64    `protobuf:"varint,1,req,name=region_id,json=regionId" json:"region_id,omitempty"`
	TableName        *TableName `protobuf:"bytes,2,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	StartKey         []byte     `protobuf:"bytes,3,opt,name=start_key,json=startKey" json:"start_key,omitempty"`
	EndKey           []byte     `protobuf:"bytes,4,opt,name=end_key,json=endKey" json:"end_key,omitempty"`
	Offline          *bool      `protobuf:"varint,5,opt,name=offline" json:"offline,omitempty"`
	Split            *bool      `protobuf:"varint,6,opt,name=split" json:"split,omitempty"`
	ReplicaId        *int32     `protobuf:"varint,7,opt,name=replica_id,json=replicaId,def=0" json:"replica_id,omitempty"`
	XXX_unrecognized []byte     `json:"-"`
}

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

const Default_RegionInfo_ReplicaId int32 = 0

func (m *RegionInfo) GetRegionId() uint64 {
	if m != nil && m.RegionId != nil {
		return *m.RegionId
	}
	return 0
}

func (m *RegionInfo) GetTableName() *TableName {
	if m != nil {
		return m.TableName
	}
	return nil
}

func (m *RegionInfo) GetStartKey() []byte {
	if m != nil {
		return m.StartKey
	}
	return nil
}

func (m *RegionInfo) GetEndKey() []byte {
	if m != nil {
		return m.EndKey
	}
	return nil
}

func (m *RegionInfo) GetOffline() bool {
	if m != nil && m.Offline != nil {
		return *m.Offline
	}
	return false
}

func (m *RegionInfo) GetSplit() bool {
	if m != nil && m.Split != nil {
		return *m.Split
	}
	return false
}

func (m *RegionInfo) GetReplicaId() int32 {
	if m != nil && m.ReplicaId != nil {
		return *m.ReplicaId
	}
	return Default_RegionInfo_ReplicaId
}

// *
// Protocol buffer for favored nodes
type FavoredNodes struct {
	FavoredNode      []*ServerName `protobuf:"bytes,1,rep,name=favored_node,json=favoredNode" json:"favored_node,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

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

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

// *
// Container protocol buffer to specify a region.
// You can specify region by region name, or the hash
// of the region name, which is known as encoded
// region name.
type RegionSpecifier struct {
	Type             *RegionSpecifier_RegionSpecifierType `protobuf:"varint,1,req,name=type,enum=pb.RegionSpecifier_RegionSpecifierType" json:"type,omitempty"`
	Value            []byte                               `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte                               `json:"-"`
}

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

func (m *RegionSpecifier) GetType() RegionSpecifier_RegionSpecifierType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return RegionSpecifier_REGION_NAME
}

func (m *RegionSpecifier) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

// *
// A range of time. Both from and to are Java time
// stamp in milliseconds. If you don't specify a time
// range, it means all time.  By default, if not
// specified, from = 0, and to = Long.MAX_VALUE
type TimeRange struct {
	From             *uint64 `protobuf:"varint,1,opt,name=from" json:"from,omitempty"`
	To               *uint64 `protobuf:"varint,2,opt,name=to" json:"to,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *TimeRange) GetFrom() uint64 {
	if m != nil && m.From != nil {
		return *m.From
	}
	return 0
}

func (m *TimeRange) GetTo() uint64 {
	if m != nil && m.To != nil {
		return *m.To
	}
	return 0
}

// ColumnFamily Specific TimeRange
type ColumnFamilyTimeRange struct {
	ColumnFamily     []byte     `protobuf:"bytes,1,req,name=column_family,json=columnFamily" json:"column_family,omitempty"`
	TimeRange        *TimeRange `protobuf:"bytes,2,req,name=time_range,json=timeRange" json:"time_range,omitempty"`
	XXX_unrecognized []byte     `json:"-"`
}

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

func (m *ColumnFamilyTimeRange) GetColumnFamily() []byte {
	if m != nil {
		return m.ColumnFamily
	}
	return nil
}

func (m *ColumnFamilyTimeRange) GetTimeRange() *TimeRange {
	if m != nil {
		return m.TimeRange
	}
	return nil
}

// *
// Protocol buffer version of ServerName
type ServerName struct {
	HostName         *string `protobuf:"bytes,1,req,name=host_name,json=hostName" json:"host_name,omitempty"`
	Port             *uint32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
	StartCode        *uint64 `protobuf:"varint,3,opt,name=start_code,json=startCode" json:"start_code,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *ServerName) GetHostName() string {
	if m != nil && m.HostName != nil {
		return *m.HostName
	}
	return ""
}

func (m *ServerName) GetPort() uint32 {
	if m != nil && m.Port != nil {
		return *m.Port
	}
	return 0
}

func (m *ServerName) GetStartCode() uint64 {
	if m != nil && m.StartCode != nil {
		return *m.StartCode
	}
	return 0
}

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

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

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

type NameStringPair struct {
	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Value            *string `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

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

func (m *NameStringPair) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

type NameBytesPair struct {
	Name             *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Value            []byte  `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

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

func (m *NameBytesPair) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type BytesBytesPair struct {
	First            []byte `protobuf:"bytes,1,req,name=first" json:"first,omitempty"`
	Second           []byte `protobuf:"bytes,2,req,name=second" json:"second,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *BytesBytesPair) GetFirst() []byte {
	if m != nil {
		return m.First
	}
	return nil
}

func (m *BytesBytesPair) GetSecond() []byte {
	if m != nil {
		return m.Second
	}
	return nil
}

type NameInt64Pair struct {
	Name             *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Value            *int64  `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

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

func (m *NameInt64Pair) GetValue() int64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

// *
// Description of the snapshot to take
type SnapshotDescription struct {
	Name             *string                   `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Table            *string                   `protobuf:"bytes,2,opt,name=table" json:"table,omitempty"`
	CreationTime     *int64                    `protobuf:"varint,3,opt,name=creation_time,json=creationTime,def=0" json:"creation_time,omitempty"`
	Type             *SnapshotDescription_Type `protobuf:"varint,4,opt,name=type,enum=pb.SnapshotDescription_Type,def=1" json:"type,omitempty"`
	Version          *int32                    `protobuf:"varint,5,opt,name=version" json:"version,omitempty"`
	Owner            *string                   `protobuf:"bytes,6,opt,name=owner" json:"owner,omitempty"`
	XXX_unrecognized []byte                    `json:"-"`
}

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

const Default_SnapshotDescription_CreationTime int64 = 0
const Default_SnapshotDescription_Type SnapshotDescription_Type = SnapshotDescription_FLUSH

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

func (m *SnapshotDescription) GetTable() string {
	if m != nil && m.Table != nil {
		return *m.Table
	}
	return ""
}

func (m *SnapshotDescription) GetCreationTime() int64 {
	if m != nil && m.CreationTime != nil {
		return *m.CreationTime
	}
	return Default_SnapshotDescription_CreationTime
}

func (m *SnapshotDescription) GetType() SnapshotDescription_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Default_SnapshotDescription_Type
}

func (m *SnapshotDescription) GetVersion() int32 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return 0
}

func (m *SnapshotDescription) GetOwner() string {
	if m != nil && m.Owner != nil {
		return *m.Owner
	}
	return ""
}

// *
// Description of the distributed procedure to take
type ProcedureDescription struct {
	Signature        *string           `protobuf:"bytes,1,req,name=signature" json:"signature,omitempty"`
	Instance         *string           `protobuf:"bytes,2,opt,name=instance" json:"instance,omitempty"`
	CreationTime     *int64            `protobuf:"varint,3,opt,name=creation_time,json=creationTime,def=0" json:"creation_time,omitempty"`
	Configuration    []*NameStringPair `protobuf:"bytes,4,rep,name=configuration" json:"configuration,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

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

const Default_ProcedureDescription_CreationTime int64 = 0

func (m *ProcedureDescription) GetSignature() string {
	if m != nil && m.Signature != nil {
		return *m.Signature
	}
	return ""
}

func (m *ProcedureDescription) GetInstance() string {
	if m != nil && m.Instance != nil {
		return *m.Instance
	}
	return ""
}

func (m *ProcedureDescription) GetCreationTime() int64 {
	if m != nil && m.CreationTime != nil {
		return *m.CreationTime
	}
	return Default_ProcedureDescription_CreationTime
}

func (m *ProcedureDescription) GetConfiguration() []*NameStringPair {
	if m != nil {
		return m.Configuration
	}
	return nil
}

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

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

type LongMsg struct {
	LongMsg          *int64 `protobuf:"varint,1,req,name=long_msg,json=longMsg" json:"long_msg,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *LongMsg) GetLongMsg() int64 {
	if m != nil && m.LongMsg != nil {
		return *m.LongMsg
	}
	return 0
}

type DoubleMsg struct {
	DoubleMsg        *float64 `protobuf:"fixed64,1,req,name=double_msg,json=doubleMsg" json:"double_msg,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *DoubleMsg) GetDoubleMsg() float64 {
	if m != nil && m.DoubleMsg != nil {
		return *m.DoubleMsg
	}
	return 0
}

type BigDecimalMsg struct {
	BigdecimalMsg    []byte `protobuf:"bytes,1,req,name=bigdecimal_msg,json=bigdecimalMsg" json:"bigdecimal_msg,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *BigDecimalMsg) GetBigdecimalMsg() []byte {
	if m != nil {
		return m.BigdecimalMsg
	}
	return nil
}

type UUID struct {
	LeastSigBits     *uint64 `protobuf:"varint,1,req,name=least_sig_bits,json=leastSigBits" json:"least_sig_bits,omitempty"`
	MostSigBits      *uint64 `protobuf:"varint,2,req,name=most_sig_bits,json=mostSigBits" json:"most_sig_bits,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *UUID) GetLeastSigBits() uint64 {
	if m != nil && m.LeastSigBits != nil {
		return *m.LeastSigBits
	}
	return 0
}

func (m *UUID) GetMostSigBits() uint64 {
	if m != nil && m.MostSigBits != nil {
		return *m.MostSigBits
	}
	return 0
}

type NamespaceDescriptor struct {
	Name             []byte            `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Configuration    []*NameStringPair `protobuf:"bytes,2,rep,name=configuration" json:"configuration,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

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

func (m *NamespaceDescriptor) GetName() []byte {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *NamespaceDescriptor) GetConfiguration() []*NameStringPair {
	if m != nil {
		return m.Configuration
	}
	return nil
}

// Rpc client version info proto. Included in ConnectionHeader on connection setup
type VersionInfo struct {
	Version          *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
	Url              *string `protobuf:"bytes,2,req,name=url" json:"url,omitempty"`
	Revision         *string `protobuf:"bytes,3,req,name=revision" json:"revision,omitempty"`
	User             *string `protobuf:"bytes,4,req,name=user" json:"user,omitempty"`
	Date             *string `protobuf:"bytes,5,req,name=date" json:"date,omitempty"`
	SrcChecksum      *string `protobuf:"bytes,6,req,name=src_checksum,json=srcChecksum" json:"src_checksum,omitempty"`
	VersionMajor     *uint32 `protobuf:"varint,7,opt,name=version_major,json=versionMajor" json:"version_major,omitempty"`
	VersionMinor     *uint32 `protobuf:"varint,8,opt,name=version_minor,json=versionMinor" json:"version_minor,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *VersionInfo) GetVersion() string {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return ""
}

func (m *VersionInfo) GetUrl() string {
	if m != nil && m.Url != nil {
		return *m.Url
	}
	return ""
}

func (m *VersionInfo) GetRevision() string {
	if m != nil && m.Revision != nil {
		return *m.Revision
	}
	return ""
}

func (m *VersionInfo) GetUser() string {
	if m != nil && m.User != nil {
		return *m.User
	}
	return ""
}

func (m *VersionInfo) GetDate() string {
	if m != nil && m.Date != nil {
		return *m.Date
	}
	return ""
}

func (m *VersionInfo) GetSrcChecksum() string {
	if m != nil && m.SrcChecksum != nil {
		return *m.SrcChecksum
	}
	return ""
}

func (m *VersionInfo) GetVersionMajor() uint32 {
	if m != nil && m.VersionMajor != nil {
		return *m.VersionMajor
	}
	return 0
}

func (m *VersionInfo) GetVersionMinor() uint32 {
	if m != nil && m.VersionMinor != nil {
		return *m.VersionMinor
	}
	return 0
}

// *
// Description of the region server info
type RegionServerInfo struct {
	InfoPort         *int32       `protobuf:"varint,1,opt,name=infoPort" json:"infoPort,omitempty"`
	VersionInfo      *VersionInfo `protobuf:"bytes,2,opt,name=version_info,json=versionInfo" json:"version_info,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

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

func (m *RegionServerInfo) GetInfoPort() int32 {
	if m != nil && m.InfoPort != nil {
		return *m.InfoPort
	}
	return 0
}

func (m *RegionServerInfo) GetVersionInfo() *VersionInfo {
	if m != nil {
		return m.VersionInfo
	}
	return nil
}

func init() {
	proto.RegisterType((*TableName)(nil), "pb.TableName")
	proto.RegisterType((*TableSchema)(nil), "pb.TableSchema")
	proto.RegisterType((*ColumnFamilySchema)(nil), "pb.ColumnFamilySchema")
	proto.RegisterType((*RegionInfo)(nil), "pb.RegionInfo")
	proto.RegisterType((*FavoredNodes)(nil), "pb.FavoredNodes")
	proto.RegisterType((*RegionSpecifier)(nil), "pb.RegionSpecifier")
	proto.RegisterType((*TimeRange)(nil), "pb.TimeRange")
	proto.RegisterType((*ColumnFamilyTimeRange)(nil), "pb.ColumnFamilyTimeRange")
	proto.RegisterType((*ServerName)(nil), "pb.ServerName")
	proto.RegisterType((*Coprocessor)(nil), "pb.Coprocessor")
	proto.RegisterType((*NameStringPair)(nil), "pb.NameStringPair")
	proto.RegisterType((*NameBytesPair)(nil), "pb.NameBytesPair")
	proto.RegisterType((*BytesBytesPair)(nil), "pb.BytesBytesPair")
	proto.RegisterType((*NameInt64Pair)(nil), "pb.NameInt64Pair")
	proto.RegisterType((*SnapshotDescription)(nil), "pb.SnapshotDescription")
	proto.RegisterType((*ProcedureDescription)(nil), "pb.ProcedureDescription")
	proto.RegisterType((*EmptyMsg)(nil), "pb.EmptyMsg")
	proto.RegisterType((*LongMsg)(nil), "pb.LongMsg")
	proto.RegisterType((*DoubleMsg)(nil), "pb.DoubleMsg")
	proto.RegisterType((*BigDecimalMsg)(nil), "pb.BigDecimalMsg")
	proto.RegisterType((*UUID)(nil), "pb.UUID")
	proto.RegisterType((*NamespaceDescriptor)(nil), "pb.NamespaceDescriptor")
	proto.RegisterType((*VersionInfo)(nil), "pb.VersionInfo")
	proto.RegisterType((*RegionServerInfo)(nil), "pb.RegionServerInfo")
	proto.RegisterEnum("pb.CompareType", CompareType_name, CompareType_value)
	proto.RegisterEnum("pb.TimeUnit", TimeUnit_name, TimeUnit_value)
	proto.RegisterEnum("pb.RegionSpecifier_RegionSpecifierType", RegionSpecifier_RegionSpecifierType_name, RegionSpecifier_RegionSpecifierType_value)
	proto.RegisterEnum("pb.SnapshotDescription_Type", SnapshotDescription_Type_name, SnapshotDescription_Type_value)
}

func init() { proto.RegisterFile("HBase.proto", fileDescriptor10) }

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