// Code generated by protoc-gen-go. DO NOT EDIT.
// source: Client.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

// *
// Consistency defines the expected consistency level for an operation.
type Consistency int32

const (
	Consistency_STRONG   Consistency = 0
	Consistency_TIMELINE Consistency = 1
)

var Consistency_name = map[int32]string{
	0: "STRONG",
	1: "TIMELINE",
}
var Consistency_value = map[string]int32{
	"STRONG":   0,
	"TIMELINE": 1,
}

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

type MutationProto_Durability int32

const (
	MutationProto_USE_DEFAULT MutationProto_Durability = 0
	MutationProto_SKIP_WAL    MutationProto_Durability = 1
	MutationProto_ASYNC_WAL   MutationProto_Durability = 2
	MutationProto_SYNC_WAL    MutationProto_Durability = 3
	MutationProto_FSYNC_WAL   MutationProto_Durability = 4
)

var MutationProto_Durability_name = map[int32]string{
	0: "USE_DEFAULT",
	1: "SKIP_WAL",
	2: "ASYNC_WAL",
	3: "SYNC_WAL",
	4: "FSYNC_WAL",
}
var MutationProto_Durability_value = map[string]int32{
	"USE_DEFAULT": 0,
	"SKIP_WAL":    1,
	"ASYNC_WAL":   2,
	"SYNC_WAL":    3,
	"FSYNC_WAL":   4,
}

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

type MutationProto_MutationType int32

const (
	MutationProto_APPEND    MutationProto_MutationType = 0
	MutationProto_INCREMENT MutationProto_MutationType = 1
	MutationProto_PUT       MutationProto_MutationType = 2
	MutationProto_DELETE    MutationProto_MutationType = 3
)

var MutationProto_MutationType_name = map[int32]string{
	0: "APPEND",
	1: "INCREMENT",
	2: "PUT",
	3: "DELETE",
}
var MutationProto_MutationType_value = map[string]int32{
	"APPEND":    0,
	"INCREMENT": 1,
	"PUT":       2,
	"DELETE":    3,
}

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

type MutationProto_DeleteType int32

const (
	MutationProto_DELETE_ONE_VERSION       MutationProto_DeleteType = 0
	MutationProto_DELETE_MULTIPLE_VERSIONS MutationProto_DeleteType = 1
	MutationProto_DELETE_FAMILY            MutationProto_DeleteType = 2
	MutationProto_DELETE_FAMILY_VERSION    MutationProto_DeleteType = 3
)

var MutationProto_DeleteType_name = map[int32]string{
	0: "DELETE_ONE_VERSION",
	1: "DELETE_MULTIPLE_VERSIONS",
	2: "DELETE_FAMILY",
	3: "DELETE_FAMILY_VERSION",
}
var MutationProto_DeleteType_value = map[string]int32{
	"DELETE_ONE_VERSION":       0,
	"DELETE_MULTIPLE_VERSIONS": 1,
	"DELETE_FAMILY":            2,
	"DELETE_FAMILY_VERSION":    3,
}

func (x MutationProto_DeleteType) Enum() *MutationProto_DeleteType {
	p := new(MutationProto_DeleteType)
	*p = x
	return p
}
func (x MutationProto_DeleteType) String() string {
	return proto.EnumName(MutationProto_DeleteType_name, int32(x))
}
func (x *MutationProto_DeleteType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(MutationProto_DeleteType_value, data, "MutationProto_DeleteType")
	if err != nil {
		return err
	}
	*x = MutationProto_DeleteType(value)
	return nil
}
func (MutationProto_DeleteType) EnumDescriptor() ([]byte, []int) { return fileDescriptor3, []int{8, 2} }

// *
// The protocol buffer version of Authorizations.
type Authorizations struct {
	Label            []string `protobuf:"bytes,1,rep,name=label" json:"label,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *Authorizations) GetLabel() []string {
	if m != nil {
		return m.Label
	}
	return nil
}

// *
// The protocol buffer version of CellVisibility.
type CellVisibility struct {
	Expression       *string `protobuf:"bytes,1,req,name=expression" json:"expression,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *CellVisibility) GetExpression() string {
	if m != nil && m.Expression != nil {
		return *m.Expression
	}
	return ""
}

// *
// Container for a list of column qualifier names of a family.
type Column struct {
	Family           []byte   `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
	Qualifier        [][]byte `protobuf:"bytes,2,rep,name=qualifier" json:"qualifier,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

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

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

// *
// The protocol buffer version of Get.
// Unless existence_only is specified, return all the requested data
// for the row that matches exactly, or the one that immediately
// precedes it if closest_row_before is specified.
type Get struct {
	Row         []byte           `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	Column      []*Column        `protobuf:"bytes,2,rep,name=column" json:"column,omitempty"`
	Attribute   []*NameBytesPair `protobuf:"bytes,3,rep,name=attribute" json:"attribute,omitempty"`
	Filter      *Filter          `protobuf:"bytes,4,opt,name=filter" json:"filter,omitempty"`
	TimeRange   *TimeRange       `protobuf:"bytes,5,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
	MaxVersions *uint32          `protobuf:"varint,6,opt,name=max_versions,json=maxVersions,def=1" json:"max_versions,omitempty"`
	CacheBlocks *bool            `protobuf:"varint,7,opt,name=cache_blocks,json=cacheBlocks,def=1" json:"cache_blocks,omitempty"`
	StoreLimit  *uint32          `protobuf:"varint,8,opt,name=store_limit,json=storeLimit" json:"store_limit,omitempty"`
	StoreOffset *uint32          `protobuf:"varint,9,opt,name=store_offset,json=storeOffset" json:"store_offset,omitempty"`
	// The result isn't asked for, just check for
	// the existence.
	ExistenceOnly *bool `protobuf:"varint,10,opt,name=existence_only,json=existenceOnly,def=0" json:"existence_only,omitempty"`
	// If the row to get doesn't exist, return the
	// closest row before.
	ClosestRowBefore *bool                    `protobuf:"varint,11,opt,name=closest_row_before,json=closestRowBefore,def=0" json:"closest_row_before,omitempty"`
	Consistency      *Consistency             `protobuf:"varint,12,opt,name=consistency,enum=pb.Consistency,def=0" json:"consistency,omitempty"`
	CfTimeRange      []*ColumnFamilyTimeRange `protobuf:"bytes,13,rep,name=cf_time_range,json=cfTimeRange" json:"cf_time_range,omitempty"`
	XXX_unrecognized []byte                   `json:"-"`
}

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

const Default_Get_MaxVersions uint32 = 1
const Default_Get_CacheBlocks bool = true
const Default_Get_ExistenceOnly bool = false
const Default_Get_ClosestRowBefore bool = false
const Default_Get_Consistency Consistency = Consistency_STRONG

func (m *Get) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *Get) GetColumn() []*Column {
	if m != nil {
		return m.Column
	}
	return nil
}

func (m *Get) GetAttribute() []*NameBytesPair {
	if m != nil {
		return m.Attribute
	}
	return nil
}

func (m *Get) GetFilter() *Filter {
	if m != nil {
		return m.Filter
	}
	return nil
}

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

func (m *Get) GetMaxVersions() uint32 {
	if m != nil && m.MaxVersions != nil {
		return *m.MaxVersions
	}
	return Default_Get_MaxVersions
}

func (m *Get) GetCacheBlocks() bool {
	if m != nil && m.CacheBlocks != nil {
		return *m.CacheBlocks
	}
	return Default_Get_CacheBlocks
}

func (m *Get) GetStoreLimit() uint32 {
	if m != nil && m.StoreLimit != nil {
		return *m.StoreLimit
	}
	return 0
}

func (m *Get) GetStoreOffset() uint32 {
	if m != nil && m.StoreOffset != nil {
		return *m.StoreOffset
	}
	return 0
}

func (m *Get) GetExistenceOnly() bool {
	if m != nil && m.ExistenceOnly != nil {
		return *m.ExistenceOnly
	}
	return Default_Get_ExistenceOnly
}

func (m *Get) GetClosestRowBefore() bool {
	if m != nil && m.ClosestRowBefore != nil {
		return *m.ClosestRowBefore
	}
	return Default_Get_ClosestRowBefore
}

func (m *Get) GetConsistency() Consistency {
	if m != nil && m.Consistency != nil {
		return *m.Consistency
	}
	return Default_Get_Consistency
}

func (m *Get) GetCfTimeRange() []*ColumnFamilyTimeRange {
	if m != nil {
		return m.CfTimeRange
	}
	return nil
}

type Result struct {
	// Result includes the Cells or else it just has a count of Cells
	// that are carried otherwise.
	Cell []*Cell `protobuf:"bytes,1,rep,name=cell" json:"cell,omitempty"`
	// The below count is set when the associated cells are
	// not part of this protobuf message; they are passed alongside
	// and then this Message is just a placeholder with metadata.
	// The count is needed to know how many to peel off the block of Cells as
	// ours.  NOTE: This is different from the pb managed cell_count of the
	// 'cell' field above which is non-null when the cells are pb'd.
	AssociatedCellCount *int32 `protobuf:"varint,2,opt,name=associated_cell_count,json=associatedCellCount" json:"associated_cell_count,omitempty"`
	// used for Get to check existence only. Not set if existence_only was not set to true
	//  in the query.
	Exists *bool `protobuf:"varint,3,opt,name=exists" json:"exists,omitempty"`
	// Whether or not the results are coming from possibly stale data
	Stale *bool `protobuf:"varint,4,opt,name=stale,def=0" json:"stale,omitempty"`
	// Whether or not the entire result could be returned. Results will be split when
	// the RPC chunk size limit is reached. Partial results contain only a subset of the
	// cells for a row and must be combined with a result containing the remaining cells
	// to form a complete result
	Partial          *bool  `protobuf:"varint,5,opt,name=partial,def=0" json:"partial,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

const Default_Result_Stale bool = false
const Default_Result_Partial bool = false

func (m *Result) GetCell() []*Cell {
	if m != nil {
		return m.Cell
	}
	return nil
}

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

func (m *Result) GetExists() bool {
	if m != nil && m.Exists != nil {
		return *m.Exists
	}
	return false
}

func (m *Result) GetStale() bool {
	if m != nil && m.Stale != nil {
		return *m.Stale
	}
	return Default_Result_Stale
}

func (m *Result) GetPartial() bool {
	if m != nil && m.Partial != nil {
		return *m.Partial
	}
	return Default_Result_Partial
}

// *
// The get request. Perform a single Get operation.
type GetRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Get              *Get             `protobuf:"bytes,2,req,name=get" json:"get,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

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

func (m *GetRequest) GetGet() *Get {
	if m != nil {
		return m.Get
	}
	return nil
}

type GetResponse struct {
	Result           *Result `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *GetResponse) GetResult() *Result {
	if m != nil {
		return m.Result
	}
	return nil
}

// *
// Condition to check if the value of a given cell (row,
// family, qualifier) matches a value via a given comparator.
//
// Condition is used in check and mutate operations.
type Condition struct {
	Row              []byte       `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	Family           []byte       `protobuf:"bytes,2,req,name=family" json:"family,omitempty"`
	Qualifier        []byte       `protobuf:"bytes,3,req,name=qualifier" json:"qualifier,omitempty"`
	CompareType      *CompareType `protobuf:"varint,4,req,name=compare_type,json=compareType,enum=pb.CompareType" json:"compare_type,omitempty"`
	Comparator       *Comparator  `protobuf:"bytes,5,req,name=comparator" json:"comparator,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

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

func (m *Condition) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

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

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

func (m *Condition) GetCompareType() CompareType {
	if m != nil && m.CompareType != nil {
		return *m.CompareType
	}
	return CompareType_LESS
}

func (m *Condition) GetComparator() *Comparator {
	if m != nil {
		return m.Comparator
	}
	return nil
}

// *
// A specific mutation inside a mutate request.
// It can be an append, increment, put or delete based
// on the mutation type.  It can be fully filled in or
// only metadata present because data is being carried
// elsewhere outside of pb.
type MutationProto struct {
	Row         []byte                       `protobuf:"bytes,1,opt,name=row" json:"row,omitempty"`
	MutateType  *MutationProto_MutationType  `protobuf:"varint,2,opt,name=mutate_type,json=mutateType,enum=pb.MutationProto_MutationType" json:"mutate_type,omitempty"`
	ColumnValue []*MutationProto_ColumnValue `protobuf:"bytes,3,rep,name=column_value,json=columnValue" json:"column_value,omitempty"`
	Timestamp   *uint64                      `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
	Attribute   []*NameBytesPair             `protobuf:"bytes,5,rep,name=attribute" json:"attribute,omitempty"`
	Durability  *MutationProto_Durability    `protobuf:"varint,6,opt,name=durability,enum=pb.MutationProto_Durability,def=0" json:"durability,omitempty"`
	// For some mutations, a result may be returned, in which case,
	// time range can be specified for potential performance gain
	TimeRange *TimeRange `protobuf:"bytes,7,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
	// The below count is set when the associated cells are NOT
	// part of this protobuf message; they are passed alongside
	// and then this Message is a placeholder with metadata.  The
	// count is needed to know how many to peel off the block of Cells as
	// ours.  NOTE: This is different from the pb managed cell_count of the
	// 'cell' field above which is non-null when the cells are pb'd.
	AssociatedCellCount *int32  `protobuf:"varint,8,opt,name=associated_cell_count,json=associatedCellCount" json:"associated_cell_count,omitempty"`
	Nonce               *uint64 `protobuf:"varint,9,opt,name=nonce" json:"nonce,omitempty"`
	XXX_unrecognized    []byte  `json:"-"`
}

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

const Default_MutationProto_Durability MutationProto_Durability = MutationProto_USE_DEFAULT

func (m *MutationProto) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *MutationProto) GetMutateType() MutationProto_MutationType {
	if m != nil && m.MutateType != nil {
		return *m.MutateType
	}
	return MutationProto_APPEND
}

func (m *MutationProto) GetColumnValue() []*MutationProto_ColumnValue {
	if m != nil {
		return m.ColumnValue
	}
	return nil
}

func (m *MutationProto) GetTimestamp() uint64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

func (m *MutationProto) GetAttribute() []*NameBytesPair {
	if m != nil {
		return m.Attribute
	}
	return nil
}

func (m *MutationProto) GetDurability() MutationProto_Durability {
	if m != nil && m.Durability != nil {
		return *m.Durability
	}
	return Default_MutationProto_Durability
}

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

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

func (m *MutationProto) GetNonce() uint64 {
	if m != nil && m.Nonce != nil {
		return *m.Nonce
	}
	return 0
}

type MutationProto_ColumnValue struct {
	Family           []byte                                      `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
	QualifierValue   []*MutationProto_ColumnValue_QualifierValue `protobuf:"bytes,2,rep,name=qualifier_value,json=qualifierValue" json:"qualifier_value,omitempty"`
	XXX_unrecognized []byte                                      `json:"-"`
}

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

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

func (m *MutationProto_ColumnValue) GetQualifierValue() []*MutationProto_ColumnValue_QualifierValue {
	if m != nil {
		return m.QualifierValue
	}
	return nil
}

type MutationProto_ColumnValue_QualifierValue struct {
	Qualifier        []byte                    `protobuf:"bytes,1,opt,name=qualifier" json:"qualifier,omitempty"`
	Value            []byte                    `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	Timestamp        *uint64                   `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"`
	DeleteType       *MutationProto_DeleteType `protobuf:"varint,4,opt,name=delete_type,json=deleteType,enum=pb.MutationProto_DeleteType" json:"delete_type,omitempty"`
	Tags             []byte                    `protobuf:"bytes,5,opt,name=tags" json:"tags,omitempty"`
	XXX_unrecognized []byte                    `json:"-"`
}

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

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

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

func (m *MutationProto_ColumnValue_QualifierValue) GetTimestamp() uint64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

func (m *MutationProto_ColumnValue_QualifierValue) GetDeleteType() MutationProto_DeleteType {
	if m != nil && m.DeleteType != nil {
		return *m.DeleteType
	}
	return MutationProto_DELETE_ONE_VERSION
}

func (m *MutationProto_ColumnValue_QualifierValue) GetTags() []byte {
	if m != nil {
		return m.Tags
	}
	return nil
}

// *
// The mutate request. Perform a single Mutate operation.
//
// Optionally, you can specify a condition. The mutate
// will take place only if the condition is met.  Otherwise,
// the mutate will be ignored.  In the response result,
// parameter processed is used to indicate if the mutate
// actually happened.
type MutateRequest struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Mutation         *MutationProto   `protobuf:"bytes,2,req,name=mutation" json:"mutation,omitempty"`
	Condition        *Condition       `protobuf:"bytes,3,opt,name=condition" json:"condition,omitempty"`
	NonceGroup       *uint64          `protobuf:"varint,4,opt,name=nonce_group,json=nonceGroup" json:"nonce_group,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

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

func (m *MutateRequest) GetMutation() *MutationProto {
	if m != nil {
		return m.Mutation
	}
	return nil
}

func (m *MutateRequest) GetCondition() *Condition {
	if m != nil {
		return m.Condition
	}
	return nil
}

func (m *MutateRequest) GetNonceGroup() uint64 {
	if m != nil && m.NonceGroup != nil {
		return *m.NonceGroup
	}
	return 0
}

type MutateResponse struct {
	Result *Result `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
	// used for mutate to indicate processed only
	Processed        *bool  `protobuf:"varint,2,opt,name=processed" json:"processed,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *MutateResponse) GetResult() *Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *MutateResponse) GetProcessed() bool {
	if m != nil && m.Processed != nil {
		return *m.Processed
	}
	return false
}

// *
// Instead of get from a table, you can scan it with optional filters.
// You can specify the row key range, time range, the columns/families
// to scan and so on.
//
// This scan is used the first time in a scan request. The response of
// the initial scan will return a scanner id, which should be used to
// fetch result batches later on before it is closed.
type Scan struct {
	Column                     []*Column                `protobuf:"bytes,1,rep,name=column" json:"column,omitempty"`
	Attribute                  []*NameBytesPair         `protobuf:"bytes,2,rep,name=attribute" json:"attribute,omitempty"`
	StartRow                   []byte                   `protobuf:"bytes,3,opt,name=start_row,json=startRow" json:"start_row,omitempty"`
	StopRow                    []byte                   `protobuf:"bytes,4,opt,name=stop_row,json=stopRow" json:"stop_row,omitempty"`
	Filter                     *Filter                  `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
	TimeRange                  *TimeRange               `protobuf:"bytes,6,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
	MaxVersions                *uint32                  `protobuf:"varint,7,opt,name=max_versions,json=maxVersions,def=1" json:"max_versions,omitempty"`
	CacheBlocks                *bool                    `protobuf:"varint,8,opt,name=cache_blocks,json=cacheBlocks,def=1" json:"cache_blocks,omitempty"`
	BatchSize                  *uint32                  `protobuf:"varint,9,opt,name=batch_size,json=batchSize" json:"batch_size,omitempty"`
	MaxResultSize              *uint64                  `protobuf:"varint,10,opt,name=max_result_size,json=maxResultSize" json:"max_result_size,omitempty"`
	StoreLimit                 *uint32                  `protobuf:"varint,11,opt,name=store_limit,json=storeLimit" json:"store_limit,omitempty"`
	StoreOffset                *uint32                  `protobuf:"varint,12,opt,name=store_offset,json=storeOffset" json:"store_offset,omitempty"`
	LoadColumnFamiliesOnDemand *bool                    `protobuf:"varint,13,opt,name=load_column_families_on_demand,json=loadColumnFamiliesOnDemand" json:"load_column_families_on_demand,omitempty"`
	Small                      *bool                    `protobuf:"varint,14,opt,name=small" json:"small,omitempty"`
	Reversed                   *bool                    `protobuf:"varint,15,opt,name=reversed,def=0" json:"reversed,omitempty"`
	Consistency                *Consistency             `protobuf:"varint,16,opt,name=consistency,enum=pb.Consistency,def=0" json:"consistency,omitempty"`
	Caching                    *uint32                  `protobuf:"varint,17,opt,name=caching" json:"caching,omitempty"`
	AllowPartialResults        *bool                    `protobuf:"varint,18,opt,name=allow_partial_results,json=allowPartialResults" json:"allow_partial_results,omitempty"`
	CfTimeRange                []*ColumnFamilyTimeRange `protobuf:"bytes,19,rep,name=cf_time_range,json=cfTimeRange" json:"cf_time_range,omitempty"`
	XXX_unrecognized           []byte                   `json:"-"`
}

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

const Default_Scan_MaxVersions uint32 = 1
const Default_Scan_CacheBlocks bool = true
const Default_Scan_Reversed bool = false
const Default_Scan_Consistency Consistency = Consistency_STRONG

func (m *Scan) GetColumn() []*Column {
	if m != nil {
		return m.Column
	}
	return nil
}

func (m *Scan) GetAttribute() []*NameBytesPair {
	if m != nil {
		return m.Attribute
	}
	return nil
}

func (m *Scan) GetStartRow() []byte {
	if m != nil {
		return m.StartRow
	}
	return nil
}

func (m *Scan) GetStopRow() []byte {
	if m != nil {
		return m.StopRow
	}
	return nil
}

func (m *Scan) GetFilter() *Filter {
	if m != nil {
		return m.Filter
	}
	return nil
}

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

func (m *Scan) GetMaxVersions() uint32 {
	if m != nil && m.MaxVersions != nil {
		return *m.MaxVersions
	}
	return Default_Scan_MaxVersions
}

func (m *Scan) GetCacheBlocks() bool {
	if m != nil && m.CacheBlocks != nil {
		return *m.CacheBlocks
	}
	return Default_Scan_CacheBlocks
}

func (m *Scan) GetBatchSize() uint32 {
	if m != nil && m.BatchSize != nil {
		return *m.BatchSize
	}
	return 0
}

func (m *Scan) GetMaxResultSize() uint64 {
	if m != nil && m.MaxResultSize != nil {
		return *m.MaxResultSize
	}
	return 0
}

func (m *Scan) GetStoreLimit() uint32 {
	if m != nil && m.StoreLimit != nil {
		return *m.StoreLimit
	}
	return 0
}

func (m *Scan) GetStoreOffset() uint32 {
	if m != nil && m.StoreOffset != nil {
		return *m.StoreOffset
	}
	return 0
}

func (m *Scan) GetLoadColumnFamiliesOnDemand() bool {
	if m != nil && m.LoadColumnFamiliesOnDemand != nil {
		return *m.LoadColumnFamiliesOnDemand
	}
	return false
}

func (m *Scan) GetSmall() bool {
	if m != nil && m.Small != nil {
		return *m.Small
	}
	return false
}

func (m *Scan) GetReversed() bool {
	if m != nil && m.Reversed != nil {
		return *m.Reversed
	}
	return Default_Scan_Reversed
}

func (m *Scan) GetConsistency() Consistency {
	if m != nil && m.Consistency != nil {
		return *m.Consistency
	}
	return Default_Scan_Consistency
}

func (m *Scan) GetCaching() uint32 {
	if m != nil && m.Caching != nil {
		return *m.Caching
	}
	return 0
}

func (m *Scan) GetAllowPartialResults() bool {
	if m != nil && m.AllowPartialResults != nil {
		return *m.AllowPartialResults
	}
	return false
}

func (m *Scan) GetCfTimeRange() []*ColumnFamilyTimeRange {
	if m != nil {
		return m.CfTimeRange
	}
	return nil
}

// *
// A scan request. Initially, it should specify a scan. Later on, you
// can use the scanner id returned to fetch result batches with a different
// scan request.
//
// The scanner will remain open if there are more results, and it's not
// asked to be closed explicitly.
//
// You can fetch the results and ask the scanner to be closed to save
// a trip if you are not interested in remaining results.
type ScanRequest struct {
	Region                  *RegionSpecifier `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"`
	Scan                    *Scan            `protobuf:"bytes,2,opt,name=scan" json:"scan,omitempty"`
	ScannerId               *uint64          `protobuf:"varint,3,opt,name=scanner_id,json=scannerId" json:"scanner_id,omitempty"`
	NumberOfRows            *uint32          `protobuf:"varint,4,opt,name=number_of_rows,json=numberOfRows" json:"number_of_rows,omitempty"`
	CloseScanner            *bool            `protobuf:"varint,5,opt,name=close_scanner,json=closeScanner" json:"close_scanner,omitempty"`
	NextCallSeq             *uint64          `protobuf:"varint,6,opt,name=next_call_seq,json=nextCallSeq" json:"next_call_seq,omitempty"`
	ClientHandlesPartials   *bool            `protobuf:"varint,7,opt,name=client_handles_partials,json=clientHandlesPartials" json:"client_handles_partials,omitempty"`
	ClientHandlesHeartbeats *bool            `protobuf:"varint,8,opt,name=client_handles_heartbeats,json=clientHandlesHeartbeats" json:"client_handles_heartbeats,omitempty"`
	TrackScanMetrics        *bool            `protobuf:"varint,9,opt,name=track_scan_metrics,json=trackScanMetrics" json:"track_scan_metrics,omitempty"`
	Renew                   *bool            `protobuf:"varint,10,opt,name=renew,def=0" json:"renew,omitempty"`
	XXX_unrecognized        []byte           `json:"-"`
}

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

const Default_ScanRequest_Renew bool = false

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

func (m *ScanRequest) GetScan() *Scan {
	if m != nil {
		return m.Scan
	}
	return nil
}

func (m *ScanRequest) GetScannerId() uint64 {
	if m != nil && m.ScannerId != nil {
		return *m.ScannerId
	}
	return 0
}

func (m *ScanRequest) GetNumberOfRows() uint32 {
	if m != nil && m.NumberOfRows != nil {
		return *m.NumberOfRows
	}
	return 0
}

func (m *ScanRequest) GetCloseScanner() bool {
	if m != nil && m.CloseScanner != nil {
		return *m.CloseScanner
	}
	return false
}

func (m *ScanRequest) GetNextCallSeq() uint64 {
	if m != nil && m.NextCallSeq != nil {
		return *m.NextCallSeq
	}
	return 0
}

func (m *ScanRequest) GetClientHandlesPartials() bool {
	if m != nil && m.ClientHandlesPartials != nil {
		return *m.ClientHandlesPartials
	}
	return false
}

func (m *ScanRequest) GetClientHandlesHeartbeats() bool {
	if m != nil && m.ClientHandlesHeartbeats != nil {
		return *m.ClientHandlesHeartbeats
	}
	return false
}

func (m *ScanRequest) GetTrackScanMetrics() bool {
	if m != nil && m.TrackScanMetrics != nil {
		return *m.TrackScanMetrics
	}
	return false
}

func (m *ScanRequest) GetRenew() bool {
	if m != nil && m.Renew != nil {
		return *m.Renew
	}
	return Default_ScanRequest_Renew
}

// *
// The scan response. If there are no more results, more_results will
// be false.  If it is not specified, it means there are more.
type ScanResponse struct {
	// This field is filled in if we are doing cellblocks.  A cellblock is made up
	// of all Cells serialized out as one cellblock BUT responses from a server
	// have their Cells grouped by Result.  So we can reconstitute the
	// Results on the client-side, this field is a list of counts of Cells
	// in each Result that makes up the response.  For example, if this field
	// has 3, 3, 3 in it, then we know that on the client, we are to make
	// three Results each of three Cells each.
	CellsPerResult []uint32 `protobuf:"varint,1,rep,name=cells_per_result,json=cellsPerResult" json:"cells_per_result,omitempty"`
	ScannerId      *uint64  `protobuf:"varint,2,opt,name=scanner_id,json=scannerId" json:"scanner_id,omitempty"`
	MoreResults    *bool    `protobuf:"varint,3,opt,name=more_results,json=moreResults" json:"more_results,omitempty"`
	Ttl            *uint32  `protobuf:"varint,4,opt,name=ttl" json:"ttl,omitempty"`
	// If cells are not carried in an accompanying cellblock, then they are pb'd here.
	// This field is mutually exclusive with cells_per_result (since the Cells will
	// be inside the pb'd Result)
	Results []*Result `protobuf:"bytes,5,rep,name=results" json:"results,omitempty"`
	Stale   *bool     `protobuf:"varint,6,opt,name=stale" json:"stale,omitempty"`
	// This field is filled in if we are doing cellblocks. In the event that a row
	// could not fit all of its cells into a single RPC chunk, the results will be
	// returned as partials, and reconstructed into a complete result on the client
	// side. This field is a list of flags indicating whether or not the result
	// that the cells belong to is a partial result. For example, if this field
	// has false, false, true in it, then we know that on the client side, we need to
	// make another RPC request since the last result was only a partial.
	PartialFlagPerResult []bool `protobuf:"varint,7,rep,name=partial_flag_per_result,json=partialFlagPerResult" json:"partial_flag_per_result,omitempty"`
	// A server may choose to limit the number of results returned to the client for
	// reasons such as the size in bytes or quantity of results accumulated. This field
	// will true when more results exist in the current region.
	MoreResultsInRegion *bool `protobuf:"varint,8,opt,name=more_results_in_region,json=moreResultsInRegion" json:"more_results_in_region,omitempty"`
	// This field is filled in if the server is sending back a heartbeat message.
	// Heartbeat messages are sent back to the client to prevent the scanner from
	// timing out. Seeing a heartbeat message communicates to the Client that the
	// server would have continued to scan had the time limit not been reached.
	HeartbeatMessage *bool  `protobuf:"varint,9,opt,name=heartbeat_message,json=heartbeatMessage" json:"heartbeat_message,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *ScanResponse) GetCellsPerResult() []uint32 {
	if m != nil {
		return m.CellsPerResult
	}
	return nil
}

func (m *ScanResponse) GetScannerId() uint64 {
	if m != nil && m.ScannerId != nil {
		return *m.ScannerId
	}
	return 0
}

func (m *ScanResponse) GetMoreResults() bool {
	if m != nil && m.MoreResults != nil {
		return *m.MoreResults
	}
	return false
}

func (m *ScanResponse) GetTtl() uint32 {
	if m != nil && m.Ttl != nil {
		return *m.Ttl
	}
	return 0
}

func (m *ScanResponse) GetResults() []*Result {
	if m != nil {
		return m.Results
	}
	return nil
}

func (m *ScanResponse) GetStale() bool {
	if m != nil && m.Stale != nil {
		return *m.Stale
	}
	return false
}

func (m *ScanResponse) GetPartialFlagPerResult() []bool {
	if m != nil {
		return m.PartialFlagPerResult
	}
	return nil
}

func (m *ScanResponse) GetMoreResultsInRegion() bool {
	if m != nil && m.MoreResultsInRegion != nil {
		return *m.MoreResultsInRegion
	}
	return false
}

func (m *ScanResponse) GetHeartbeatMessage() bool {
	if m != nil && m.HeartbeatMessage != nil {
		return *m.HeartbeatMessage
	}
	return false
}

// *
// Atomically bulk load multiple HFiles (say from different column families)
// into an open region.
type BulkLoadHFileRequest struct {
	Region           *RegionSpecifier                   `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	FamilyPath       []*BulkLoadHFileRequest_FamilyPath `protobuf:"bytes,2,rep,name=family_path,json=familyPath" json:"family_path,omitempty"`
	AssignSeqNum     *bool                              `protobuf:"varint,3,opt,name=assign_seq_num,json=assignSeqNum" json:"assign_seq_num,omitempty"`
	XXX_unrecognized []byte                             `json:"-"`
}

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

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

func (m *BulkLoadHFileRequest) GetFamilyPath() []*BulkLoadHFileRequest_FamilyPath {
	if m != nil {
		return m.FamilyPath
	}
	return nil
}

func (m *BulkLoadHFileRequest) GetAssignSeqNum() bool {
	if m != nil && m.AssignSeqNum != nil {
		return *m.AssignSeqNum
	}
	return false
}

type BulkLoadHFileRequest_FamilyPath struct {
	Family           []byte  `protobuf:"bytes,1,req,name=family" json:"family,omitempty"`
	Path             *string `protobuf:"bytes,2,req,name=path" json:"path,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

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

func (m *BulkLoadHFileRequest_FamilyPath) GetPath() string {
	if m != nil && m.Path != nil {
		return *m.Path
	}
	return ""
}

type BulkLoadHFileResponse struct {
	Loaded           *bool  `protobuf:"varint,1,req,name=loaded" json:"loaded,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *BulkLoadHFileResponse) GetLoaded() bool {
	if m != nil && m.Loaded != nil {
		return *m.Loaded
	}
	return false
}

type CoprocessorServiceCall struct {
	Row              []byte  `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	ServiceName      *string `protobuf:"bytes,2,req,name=service_name,json=serviceName" json:"service_name,omitempty"`
	MethodName       *string `protobuf:"bytes,3,req,name=method_name,json=methodName" json:"method_name,omitempty"`
	Request          []byte  `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *CoprocessorServiceCall) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *CoprocessorServiceCall) GetServiceName() string {
	if m != nil && m.ServiceName != nil {
		return *m.ServiceName
	}
	return ""
}

func (m *CoprocessorServiceCall) GetMethodName() string {
	if m != nil && m.MethodName != nil {
		return *m.MethodName
	}
	return ""
}

func (m *CoprocessorServiceCall) GetRequest() []byte {
	if m != nil {
		return m.Request
	}
	return nil
}

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

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

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

type CoprocessorServiceRequest struct {
	Region           *RegionSpecifier        `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Call             *CoprocessorServiceCall `protobuf:"bytes,2,req,name=call" json:"call,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

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

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

func (m *CoprocessorServiceRequest) GetCall() *CoprocessorServiceCall {
	if m != nil {
		return m.Call
	}
	return nil
}

type CoprocessorServiceResponse struct {
	Region           *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	Value            *NameBytesPair   `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

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

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

// Either a Get or a Mutation
type Action struct {
	// If part of a multi action, useful aligning
	// result with what was originally submitted.
	Index            *uint32                 `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
	Mutation         *MutationProto          `protobuf:"bytes,2,opt,name=mutation" json:"mutation,omitempty"`
	Get              *Get                    `protobuf:"bytes,3,opt,name=get" json:"get,omitempty"`
	ServiceCall      *CoprocessorServiceCall `protobuf:"bytes,4,opt,name=service_call,json=serviceCall" json:"service_call,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

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

func (m *Action) GetIndex() uint32 {
	if m != nil && m.Index != nil {
		return *m.Index
	}
	return 0
}

func (m *Action) GetMutation() *MutationProto {
	if m != nil {
		return m.Mutation
	}
	return nil
}

func (m *Action) GetGet() *Get {
	if m != nil {
		return m.Get
	}
	return nil
}

func (m *Action) GetServiceCall() *CoprocessorServiceCall {
	if m != nil {
		return m.ServiceCall
	}
	return nil
}

// *
// Actions to run against a Region.
type RegionAction struct {
	Region *RegionSpecifier `protobuf:"bytes,1,req,name=region" json:"region,omitempty"`
	// When set, run mutations as atomic unit.
	Atomic           *bool     `protobuf:"varint,2,opt,name=atomic" json:"atomic,omitempty"`
	Action           []*Action `protobuf:"bytes,3,rep,name=action" json:"action,omitempty"`
	XXX_unrecognized []byte    `json:"-"`
}

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

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

func (m *RegionAction) GetAtomic() bool {
	if m != nil && m.Atomic != nil {
		return *m.Atomic
	}
	return false
}

func (m *RegionAction) GetAction() []*Action {
	if m != nil {
		return m.Action
	}
	return nil
}

//
// Statistics about the current load on the region
type RegionLoadStats struct {
	// Percent load on the memstore. Guaranteed to be positive, between 0 and 100.
	MemstoreLoad *int32 `protobuf:"varint,1,opt,name=memstoreLoad,def=0" json:"memstoreLoad,omitempty"`
	// Percent JVM heap occupancy. Guaranteed to be positive, between 0 and 100.
	// We can move this to "ServerLoadStats" should we develop them.
	HeapOccupancy *int32 `protobuf:"varint,2,opt,name=heapOccupancy,def=0" json:"heapOccupancy,omitempty"`
	// Compaction pressure. Guaranteed to be positive, between 0 and 100.
	CompactionPressure *int32 `protobuf:"varint,3,opt,name=compactionPressure,def=0" json:"compactionPressure,omitempty"`
	XXX_unrecognized   []byte `json:"-"`
}

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

const Default_RegionLoadStats_MemstoreLoad int32 = 0
const Default_RegionLoadStats_HeapOccupancy int32 = 0
const Default_RegionLoadStats_CompactionPressure int32 = 0

func (m *RegionLoadStats) GetMemstoreLoad() int32 {
	if m != nil && m.MemstoreLoad != nil {
		return *m.MemstoreLoad
	}
	return Default_RegionLoadStats_MemstoreLoad
}

func (m *RegionLoadStats) GetHeapOccupancy() int32 {
	if m != nil && m.HeapOccupancy != nil {
		return *m.HeapOccupancy
	}
	return Default_RegionLoadStats_HeapOccupancy
}

func (m *RegionLoadStats) GetCompactionPressure() int32 {
	if m != nil && m.CompactionPressure != nil {
		return *m.CompactionPressure
	}
	return Default_RegionLoadStats_CompactionPressure
}

type MultiRegionLoadStats struct {
	Region           []*RegionSpecifier `protobuf:"bytes,1,rep,name=region" json:"region,omitempty"`
	Stat             []*RegionLoadStats `protobuf:"bytes,2,rep,name=stat" json:"stat,omitempty"`
	XXX_unrecognized []byte             `json:"-"`
}

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

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

func (m *MultiRegionLoadStats) GetStat() []*RegionLoadStats {
	if m != nil {
		return m.Stat
	}
	return nil
}

// *
// Either a Result or an Exception NameBytesPair (keyed by
// exception name whose value is the exception stringified)
// or maybe empty if no result and no exception.
type ResultOrException struct {
	// If part of a multi call, save original index of the list of all
	// passed so can align this response w/ original request.
	Index     *uint32        `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
	Result    *Result        `protobuf:"bytes,2,opt,name=result" json:"result,omitempty"`
	Exception *NameBytesPair `protobuf:"bytes,3,opt,name=exception" json:"exception,omitempty"`
	// result if this was a coprocessor service call
	ServiceResult *CoprocessorServiceResult `protobuf:"bytes,4,opt,name=service_result,json=serviceResult" json:"service_result,omitempty"`
	// current load on the region
	LoadStats        *RegionLoadStats `protobuf:"bytes,5,opt,name=loadStats" json:"loadStats,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

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

func (m *ResultOrException) GetIndex() uint32 {
	if m != nil && m.Index != nil {
		return *m.Index
	}
	return 0
}

func (m *ResultOrException) GetResult() *Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *ResultOrException) GetException() *NameBytesPair {
	if m != nil {
		return m.Exception
	}
	return nil
}

func (m *ResultOrException) GetServiceResult() *CoprocessorServiceResult {
	if m != nil {
		return m.ServiceResult
	}
	return nil
}

func (m *ResultOrException) GetLoadStats() *RegionLoadStats {
	if m != nil {
		return m.LoadStats
	}
	return nil
}

// *
// The result of a RegionAction.
type RegionActionResult struct {
	ResultOrException []*ResultOrException `protobuf:"bytes,1,rep,name=resultOrException" json:"resultOrException,omitempty"`
	// If the operation failed globally for this region, this exception is set
	Exception        *NameBytesPair `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
	XXX_unrecognized []byte         `json:"-"`
}

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

func (m *RegionActionResult) GetResultOrException() []*ResultOrException {
	if m != nil {
		return m.ResultOrException
	}
	return nil
}

func (m *RegionActionResult) GetException() *NameBytesPair {
	if m != nil {
		return m.Exception
	}
	return nil
}

// *
// Execute a list of actions on a given region in order.
// Nothing prevents a request to contains a set of RegionAction on the same region.
// For this reason, the matching between the MultiRequest and the MultiResponse is not
//  done by the region specifier but by keeping the order of the RegionActionResult vs.
//  the order of the RegionAction.
type MultiRequest struct {
	RegionAction     []*RegionAction `protobuf:"bytes,1,rep,name=regionAction" json:"regionAction,omitempty"`
	NonceGroup       *uint64         `protobuf:"varint,2,opt,name=nonceGroup" json:"nonceGroup,omitempty"`
	Condition        *Condition      `protobuf:"bytes,3,opt,name=condition" json:"condition,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

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

func (m *MultiRequest) GetRegionAction() []*RegionAction {
	if m != nil {
		return m.RegionAction
	}
	return nil
}

func (m *MultiRequest) GetNonceGroup() uint64 {
	if m != nil && m.NonceGroup != nil {
		return *m.NonceGroup
	}
	return 0
}

func (m *MultiRequest) GetCondition() *Condition {
	if m != nil {
		return m.Condition
	}
	return nil
}

type MultiResponse struct {
	RegionActionResult []*RegionActionResult `protobuf:"bytes,1,rep,name=regionActionResult" json:"regionActionResult,omitempty"`
	// used for mutate to indicate processed only
	Processed        *bool                 `protobuf:"varint,2,opt,name=processed" json:"processed,omitempty"`
	RegionStatistics *MultiRegionLoadStats `protobuf:"bytes,3,opt,name=regionStatistics" json:"regionStatistics,omitempty"`
	XXX_unrecognized []byte                `json:"-"`
}

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

func (m *MultiResponse) GetRegionActionResult() []*RegionActionResult {
	if m != nil {
		return m.RegionActionResult
	}
	return nil
}

func (m *MultiResponse) GetProcessed() bool {
	if m != nil && m.Processed != nil {
		return *m.Processed
	}
	return false
}

func (m *MultiResponse) GetRegionStatistics() *MultiRegionLoadStats {
	if m != nil {
		return m.RegionStatistics
	}
	return nil
}

func init() {
	proto.RegisterType((*Authorizations)(nil), "pb.Authorizations")
	proto.RegisterType((*CellVisibility)(nil), "pb.CellVisibility")
	proto.RegisterType((*Column)(nil), "pb.Column")
	proto.RegisterType((*Get)(nil), "pb.Get")
	proto.RegisterType((*Result)(nil), "pb.Result")
	proto.RegisterType((*GetRequest)(nil), "pb.GetRequest")
	proto.RegisterType((*GetResponse)(nil), "pb.GetResponse")
	proto.RegisterType((*Condition)(nil), "pb.Condition")
	proto.RegisterType((*MutationProto)(nil), "pb.MutationProto")
	proto.RegisterType((*MutationProto_ColumnValue)(nil), "pb.MutationProto.ColumnValue")
	proto.RegisterType((*MutationProto_ColumnValue_QualifierValue)(nil), "pb.MutationProto.ColumnValue.QualifierValue")
	proto.RegisterType((*MutateRequest)(nil), "pb.MutateRequest")
	proto.RegisterType((*MutateResponse)(nil), "pb.MutateResponse")
	proto.RegisterType((*Scan)(nil), "pb.Scan")
	proto.RegisterType((*ScanRequest)(nil), "pb.ScanRequest")
	proto.RegisterType((*ScanResponse)(nil), "pb.ScanResponse")
	proto.RegisterType((*BulkLoadHFileRequest)(nil), "pb.BulkLoadHFileRequest")
	proto.RegisterType((*BulkLoadHFileRequest_FamilyPath)(nil), "pb.BulkLoadHFileRequest.FamilyPath")
	proto.RegisterType((*BulkLoadHFileResponse)(nil), "pb.BulkLoadHFileResponse")
	proto.RegisterType((*CoprocessorServiceCall)(nil), "pb.CoprocessorServiceCall")
	proto.RegisterType((*CoprocessorServiceResult)(nil), "pb.CoprocessorServiceResult")
	proto.RegisterType((*CoprocessorServiceRequest)(nil), "pb.CoprocessorServiceRequest")
	proto.RegisterType((*CoprocessorServiceResponse)(nil), "pb.CoprocessorServiceResponse")
	proto.RegisterType((*Action)(nil), "pb.Action")
	proto.RegisterType((*RegionAction)(nil), "pb.RegionAction")
	proto.RegisterType((*RegionLoadStats)(nil), "pb.RegionLoadStats")
	proto.RegisterType((*MultiRegionLoadStats)(nil), "pb.MultiRegionLoadStats")
	proto.RegisterType((*ResultOrException)(nil), "pb.ResultOrException")
	proto.RegisterType((*RegionActionResult)(nil), "pb.RegionActionResult")
	proto.RegisterType((*MultiRequest)(nil), "pb.MultiRequest")
	proto.RegisterType((*MultiResponse)(nil), "pb.MultiResponse")
	proto.RegisterEnum("pb.Consistency", Consistency_name, Consistency_value)
	proto.RegisterEnum("pb.MutationProto_Durability", MutationProto_Durability_name, MutationProto_Durability_value)
	proto.RegisterEnum("pb.MutationProto_MutationType", MutationProto_MutationType_name, MutationProto_MutationType_value)
	proto.RegisterEnum("pb.MutationProto_DeleteType", MutationProto_DeleteType_name, MutationProto_DeleteType_value)
}

func init() { proto.RegisterFile("Client.proto", fileDescriptor3) }

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