new repo

[bytom/vapor.git] / vendor / google.golang.org / genproto / googleapis / bigtable / v2 / bigtable.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/bigtable/v2/bigtable.proto

/*
Package bigtable is a generated protocol buffer package.

It is generated from these files:
        google/bigtable/v2/bigtable.proto
        google/bigtable/v2/data.proto

It has these top-level messages:
        ReadRowsRequest
        ReadRowsResponse
        SampleRowKeysRequest
        SampleRowKeysResponse
        MutateRowRequest
        MutateRowResponse
        MutateRowsRequest
        MutateRowsResponse
        CheckAndMutateRowRequest
        CheckAndMutateRowResponse
        ReadModifyWriteRowRequest
        ReadModifyWriteRowResponse
        Row
        Family
        Column
        Cell
        RowRange
        RowSet
        ColumnRange
        TimestampRange
        ValueRange
        RowFilter
        Mutation
        ReadModifyWriteRule
*/
package bigtable

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import google_protobuf1 "github.com/golang/protobuf/ptypes/wrappers"
import google_rpc "google.golang.org/genproto/googleapis/rpc/status"

import (
        context "golang.org/x/net/context"
        grpc "google.golang.org/grpc"
)

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

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

// Request message for Bigtable.ReadRows.
type ReadRowsRequest struct {
        // The unique name of the table from which to read.
        // Values are of the form
        // `projects/<project>/instances/<instance>/tables/<table>`.
        TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
        // The row keys and/or ranges to read. If not specified, reads from all rows.
        Rows *RowSet `protobuf:"bytes,2,opt,name=rows" json:"rows,omitempty"`
        // The filter to apply to the contents of the specified row(s). If unset,
        // reads the entirety of each row.
        Filter *RowFilter `protobuf:"bytes,3,opt,name=filter" json:"filter,omitempty"`
        // The read will terminate after committing to N rows' worth of results. The
        // default (zero) is to return all results.
        RowsLimit int64 `protobuf:"varint,4,opt,name=rows_limit,json=rowsLimit" json:"rows_limit,omitempty"`
}

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

func (m *ReadRowsRequest) GetTableName() string {
        if m != nil {
                return m.TableName
        }
        return ""
}

func (m *ReadRowsRequest) GetRows() *RowSet {
        if m != nil {
                return m.Rows
        }
        return nil
}

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

func (m *ReadRowsRequest) GetRowsLimit() int64 {
        if m != nil {
                return m.RowsLimit
        }
        return 0
}

// Response message for Bigtable.ReadRows.
type ReadRowsResponse struct {
        Chunks []*ReadRowsResponse_CellChunk `protobuf:"bytes,1,rep,name=chunks" json:"chunks,omitempty"`
        // Optionally the server might return the row key of the last row it
        // has scanned.  The client can use this to construct a more
        // efficient retry request if needed: any row keys or portions of
        // ranges less than this row key can be dropped from the request.
        // This is primarily useful for cases where the server has read a
        // lot of data that was filtered out since the last committed row
        // key, allowing the client to skip that work on a retry.
        LastScannedRowKey []byte `protobuf:"bytes,2,opt,name=last_scanned_row_key,json=lastScannedRowKey,proto3" json:"last_scanned_row_key,omitempty"`
}

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

func (m *ReadRowsResponse) GetChunks() []*ReadRowsResponse_CellChunk {
        if m != nil {
                return m.Chunks
        }
        return nil
}

func (m *ReadRowsResponse) GetLastScannedRowKey() []byte {
        if m != nil {
                return m.LastScannedRowKey
        }
        return nil
}

// Specifies a piece of a row's contents returned as part of the read
// response stream.
type ReadRowsResponse_CellChunk struct {
        // The row key for this chunk of data.  If the row key is empty,
        // this CellChunk is a continuation of the same row as the previous
        // CellChunk in the response stream, even if that CellChunk was in a
        // previous ReadRowsResponse message.
        RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
        // The column family name for this chunk of data.  If this message
        // is not present this CellChunk is a continuation of the same column
        // family as the previous CellChunk.  The empty string can occur as a
        // column family name in a response so clients must check
        // explicitly for the presence of this message, not just for
        // `family_name.value` being non-empty.
        FamilyName *google_protobuf1.StringValue `protobuf:"bytes,2,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
        // The column qualifier for this chunk of data.  If this message
        // is not present, this CellChunk is a continuation of the same column
        // as the previous CellChunk.  Column qualifiers may be empty so
        // clients must check for the presence of this message, not just
        // for `qualifier.value` being non-empty.
        Qualifier *google_protobuf1.BytesValue `protobuf:"bytes,3,opt,name=qualifier" json:"qualifier,omitempty"`
        // The cell's stored timestamp, which also uniquely identifies it
        // within its column.  Values are always expressed in
        // microseconds, but individual tables may set a coarser
        // granularity to further restrict the allowed values. For
        // example, a table which specifies millisecond granularity will
        // only allow values of `timestamp_micros` which are multiples of
        // 1000.  Timestamps are only set in the first CellChunk per cell
        // (for cells split into multiple chunks).
        TimestampMicros int64 `protobuf:"varint,4,opt,name=timestamp_micros,json=timestampMicros" json:"timestamp_micros,omitempty"`
        // Labels applied to the cell by a
        // [RowFilter][google.bigtable.v2.RowFilter].  Labels are only set
        // on the first CellChunk per cell.
        Labels []string `protobuf:"bytes,5,rep,name=labels" json:"labels,omitempty"`
        // The value stored in the cell.  Cell values can be split across
        // multiple CellChunks.  In that case only the value field will be
        // set in CellChunks after the first: the timestamp and labels
        // will only be present in the first CellChunk, even if the first
        // CellChunk came in a previous ReadRowsResponse.
        Value []byte `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"`
        // If this CellChunk is part of a chunked cell value and this is
        // not the final chunk of that cell, value_size will be set to the
        // total length of the cell value.  The client can use this size
        // to pre-allocate memory to hold the full cell value.
        ValueSize int32 `protobuf:"varint,7,opt,name=value_size,json=valueSize" json:"value_size,omitempty"`
        // Types that are valid to be assigned to RowStatus:
        //      *ReadRowsResponse_CellChunk_ResetRow
        //      *ReadRowsResponse_CellChunk_CommitRow
        RowStatus isReadRowsResponse_CellChunk_RowStatus `protobuf_oneof:"row_status"`
}

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

type isReadRowsResponse_CellChunk_RowStatus interface {
        isReadRowsResponse_CellChunk_RowStatus()
}

type ReadRowsResponse_CellChunk_ResetRow struct {
        ResetRow bool `protobuf:"varint,8,opt,name=reset_row,json=resetRow,oneof"`
}
type ReadRowsResponse_CellChunk_CommitRow struct {
        CommitRow bool `protobuf:"varint,9,opt,name=commit_row,json=commitRow,oneof"`
}

func (*ReadRowsResponse_CellChunk_ResetRow) isReadRowsResponse_CellChunk_RowStatus()  {}
func (*ReadRowsResponse_CellChunk_CommitRow) isReadRowsResponse_CellChunk_RowStatus() {}

func (m *ReadRowsResponse_CellChunk) GetRowStatus() isReadRowsResponse_CellChunk_RowStatus {
        if m != nil {
                return m.RowStatus
        }
        return nil
}

func (m *ReadRowsResponse_CellChunk) GetRowKey() []byte {
        if m != nil {
                return m.RowKey
        }
        return nil
}

func (m *ReadRowsResponse_CellChunk) GetFamilyName() *google_protobuf1.StringValue {
        if m != nil {
                return m.FamilyName
        }
        return nil
}

func (m *ReadRowsResponse_CellChunk) GetQualifier() *google_protobuf1.BytesValue {
        if m != nil {
                return m.Qualifier
        }
        return nil
}

func (m *ReadRowsResponse_CellChunk) GetTimestampMicros() int64 {
        if m != nil {
                return m.TimestampMicros
        }
        return 0
}

func (m *ReadRowsResponse_CellChunk) GetLabels() []string {
        if m != nil {
                return m.Labels
        }
        return nil
}

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

func (m *ReadRowsResponse_CellChunk) GetValueSize() int32 {
        if m != nil {
                return m.ValueSize
        }
        return 0
}

func (m *ReadRowsResponse_CellChunk) GetResetRow() bool {
        if x, ok := m.GetRowStatus().(*ReadRowsResponse_CellChunk_ResetRow); ok {
                return x.ResetRow
        }
        return false
}

func (m *ReadRowsResponse_CellChunk) GetCommitRow() bool {
        if x, ok := m.GetRowStatus().(*ReadRowsResponse_CellChunk_CommitRow); ok {
                return x.CommitRow
        }
        return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ReadRowsResponse_CellChunk) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
        return _ReadRowsResponse_CellChunk_OneofMarshaler, _ReadRowsResponse_CellChunk_OneofUnmarshaler, _ReadRowsResponse_CellChunk_OneofSizer, []interface{}{
                (*ReadRowsResponse_CellChunk_ResetRow)(nil),
                (*ReadRowsResponse_CellChunk_CommitRow)(nil),
        }
}

func _ReadRowsResponse_CellChunk_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
        m := msg.(*ReadRowsResponse_CellChunk)
        // row_status
        switch x := m.RowStatus.(type) {
        case *ReadRowsResponse_CellChunk_ResetRow:
                t := uint64(0)
                if x.ResetRow {
                        t = 1
                }
                b.EncodeVarint(8<<3 | proto.WireVarint)
                b.EncodeVarint(t)
        case *ReadRowsResponse_CellChunk_CommitRow:
                t := uint64(0)
                if x.CommitRow {
                        t = 1
                }
                b.EncodeVarint(9<<3 | proto.WireVarint)
                b.EncodeVarint(t)
        case nil:
        default:
                return fmt.Errorf("ReadRowsResponse_CellChunk.RowStatus has unexpected type %T", x)
        }
        return nil
}

func _ReadRowsResponse_CellChunk_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
        m := msg.(*ReadRowsResponse_CellChunk)
        switch tag {
        case 8: // row_status.reset_row
                if wire != proto.WireVarint {
                        return true, proto.ErrInternalBadWireType
                }
                x, err := b.DecodeVarint()
                m.RowStatus = &ReadRowsResponse_CellChunk_ResetRow{x != 0}
                return true, err
        case 9: // row_status.commit_row
                if wire != proto.WireVarint {
                        return true, proto.ErrInternalBadWireType
                }
                x, err := b.DecodeVarint()
                m.RowStatus = &ReadRowsResponse_CellChunk_CommitRow{x != 0}
                return true, err
        default:
                return false, nil
        }
}

func _ReadRowsResponse_CellChunk_OneofSizer(msg proto.Message) (n int) {
        m := msg.(*ReadRowsResponse_CellChunk)
        // row_status
        switch x := m.RowStatus.(type) {
        case *ReadRowsResponse_CellChunk_ResetRow:
                n += proto.SizeVarint(8<<3 | proto.WireVarint)
                n += 1
        case *ReadRowsResponse_CellChunk_CommitRow:
                n += proto.SizeVarint(9<<3 | proto.WireVarint)
                n += 1
        case nil:
        default:
                panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
        }
        return n
}

// Request message for Bigtable.SampleRowKeys.
type SampleRowKeysRequest struct {
        // The unique name of the table from which to sample row keys.
        // Values are of the form
        // `projects/<project>/instances/<instance>/tables/<table>`.
        TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
}

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

func (m *SampleRowKeysRequest) GetTableName() string {
        if m != nil {
                return m.TableName
        }
        return ""
}

// Response message for Bigtable.SampleRowKeys.
type SampleRowKeysResponse struct {
        // Sorted streamed sequence of sample row keys in the table. The table might
        // have contents before the first row key in the list and after the last one,
        // but a key containing the empty string indicates "end of table" and will be
        // the last response given, if present.
        // Note that row keys in this list may not have ever been written to or read
        // from, and users should therefore not make any assumptions about the row key
        // structure that are specific to their use case.
        RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
        // Approximate total storage space used by all rows in the table which precede
        // `row_key`. Buffering the contents of all rows between two subsequent
        // samples would require space roughly equal to the difference in their
        // `offset_bytes` fields.
        OffsetBytes int64 `protobuf:"varint,2,opt,name=offset_bytes,json=offsetBytes" json:"offset_bytes,omitempty"`
}

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

func (m *SampleRowKeysResponse) GetRowKey() []byte {
        if m != nil {
                return m.RowKey
        }
        return nil
}

func (m *SampleRowKeysResponse) GetOffsetBytes() int64 {
        if m != nil {
                return m.OffsetBytes
        }
        return 0
}

// Request message for Bigtable.MutateRow.
type MutateRowRequest struct {
        // The unique name of the table to which the mutation should be applied.
        // Values are of the form
        // `projects/<project>/instances/<instance>/tables/<table>`.
        TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
        // The key of the row to which the mutation should be applied.
        RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
        // Changes to be atomically applied to the specified row. Entries are applied
        // in order, meaning that earlier mutations can be masked by later ones.
        // Must contain at least one entry and at most 100000.
        Mutations []*Mutation `protobuf:"bytes,3,rep,name=mutations" json:"mutations,omitempty"`
}

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

func (m *MutateRowRequest) GetTableName() string {
        if m != nil {
                return m.TableName
        }
        return ""
}

func (m *MutateRowRequest) GetRowKey() []byte {
        if m != nil {
                return m.RowKey
        }
        return nil
}

func (m *MutateRowRequest) GetMutations() []*Mutation {
        if m != nil {
                return m.Mutations
        }
        return nil
}

// Response message for Bigtable.MutateRow.
type MutateRowResponse struct {
}

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

// Request message for BigtableService.MutateRows.
type MutateRowsRequest struct {
        // The unique name of the table to which the mutations should be applied.
        TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
        // The row keys and corresponding mutations to be applied in bulk.
        // Each entry is applied as an atomic mutation, but the entries may be
        // applied in arbitrary order (even between entries for the same row).
        // At least one entry must be specified, and in total the entries can
        // contain at most 100000 mutations.
        Entries []*MutateRowsRequest_Entry `protobuf:"bytes,2,rep,name=entries" json:"entries,omitempty"`
}

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

func (m *MutateRowsRequest) GetTableName() string {
        if m != nil {
                return m.TableName
        }
        return ""
}

func (m *MutateRowsRequest) GetEntries() []*MutateRowsRequest_Entry {
        if m != nil {
                return m.Entries
        }
        return nil
}

type MutateRowsRequest_Entry struct {
        // The key of the row to which the `mutations` should be applied.
        RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
        // Changes to be atomically applied to the specified row. Mutations are
        // applied in order, meaning that earlier mutations can be masked by
        // later ones.
        // You must specify at least one mutation.
        Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"`
}

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

func (m *MutateRowsRequest_Entry) GetRowKey() []byte {
        if m != nil {
                return m.RowKey
        }
        return nil
}

func (m *MutateRowsRequest_Entry) GetMutations() []*Mutation {
        if m != nil {
                return m.Mutations
        }
        return nil
}

// Response message for BigtableService.MutateRows.
type MutateRowsResponse struct {
        // One or more results for Entries from the batch request.
        Entries []*MutateRowsResponse_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
}

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

func (m *MutateRowsResponse) GetEntries() []*MutateRowsResponse_Entry {
        if m != nil {
                return m.Entries
        }
        return nil
}

type MutateRowsResponse_Entry struct {
        // The index into the original request's `entries` list of the Entry
        // for which a result is being reported.
        Index int64 `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
        // The result of the request Entry identified by `index`.
        // Depending on how requests are batched during execution, it is possible
        // for one Entry to fail due to an error with another Entry. In the event
        // that this occurs, the same error will be reported for both entries.
        Status *google_rpc.Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

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

func (m *MutateRowsResponse_Entry) GetIndex() int64 {
        if m != nil {
                return m.Index
        }
        return 0
}

func (m *MutateRowsResponse_Entry) GetStatus() *google_rpc.Status {
        if m != nil {
                return m.Status
        }
        return nil
}

// Request message for Bigtable.CheckAndMutateRow.
type CheckAndMutateRowRequest struct {
        // The unique name of the table to which the conditional mutation should be
        // applied.
        // Values are of the form
        // `projects/<project>/instances/<instance>/tables/<table>`.
        TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
        // The key of the row to which the conditional mutation should be applied.
        RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
        // The filter to be applied to the contents of the specified row. Depending
        // on whether or not any results are yielded, either `true_mutations` or
        // `false_mutations` will be executed. If unset, checks that the row contains
        // any values at all.
        PredicateFilter *RowFilter `protobuf:"bytes,6,opt,name=predicate_filter,json=predicateFilter" json:"predicate_filter,omitempty"`
        // Changes to be atomically applied to the specified row if `predicate_filter`
        // yields at least one cell when applied to `row_key`. Entries are applied in
        // order, meaning that earlier mutations can be masked by later ones.
        // Must contain at least one entry if `false_mutations` is empty, and at most
        // 100000.
        TrueMutations []*Mutation `protobuf:"bytes,4,rep,name=true_mutations,json=trueMutations" json:"true_mutations,omitempty"`
        // Changes to be atomically applied to the specified row if `predicate_filter`
        // does not yield any cells when applied to `row_key`. Entries are applied in
        // order, meaning that earlier mutations can be masked by later ones.
        // Must contain at least one entry if `true_mutations` is empty, and at most
        // 100000.
        FalseMutations []*Mutation `protobuf:"bytes,5,rep,name=false_mutations,json=falseMutations" json:"false_mutations,omitempty"`
}

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

func (m *CheckAndMutateRowRequest) GetTableName() string {
        if m != nil {
                return m.TableName
        }
        return ""
}

func (m *CheckAndMutateRowRequest) GetRowKey() []byte {
        if m != nil {
                return m.RowKey
        }
        return nil
}

func (m *CheckAndMutateRowRequest) GetPredicateFilter() *RowFilter {
        if m != nil {
                return m.PredicateFilter
        }
        return nil
}

func (m *CheckAndMutateRowRequest) GetTrueMutations() []*Mutation {
        if m != nil {
                return m.TrueMutations
        }
        return nil
}

func (m *CheckAndMutateRowRequest) GetFalseMutations() []*Mutation {
        if m != nil {
                return m.FalseMutations
        }
        return nil
}

// Response message for Bigtable.CheckAndMutateRow.
type CheckAndMutateRowResponse struct {
        // Whether or not the request's `predicate_filter` yielded any results for
        // the specified row.
        PredicateMatched bool `protobuf:"varint,1,opt,name=predicate_matched,json=predicateMatched" json:"predicate_matched,omitempty"`
}

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

func (m *CheckAndMutateRowResponse) GetPredicateMatched() bool {
        if m != nil {
                return m.PredicateMatched
        }
        return false
}

// Request message for Bigtable.ReadModifyWriteRow.
type ReadModifyWriteRowRequest struct {
        // The unique name of the table to which the read/modify/write rules should be
        // applied.
        // Values are of the form
        // `projects/<project>/instances/<instance>/tables/<table>`.
        TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
        // The key of the row to which the read/modify/write rules should be applied.
        RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
        // Rules specifying how the specified row's contents are to be transformed
        // into writes. Entries are applied in order, meaning that earlier rules will
        // affect the results of later ones.
        Rules []*ReadModifyWriteRule `protobuf:"bytes,3,rep,name=rules" json:"rules,omitempty"`
}

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

func (m *ReadModifyWriteRowRequest) GetTableName() string {
        if m != nil {
                return m.TableName
        }
        return ""
}

func (m *ReadModifyWriteRowRequest) GetRowKey() []byte {
        if m != nil {
                return m.RowKey
        }
        return nil
}

func (m *ReadModifyWriteRowRequest) GetRules() []*ReadModifyWriteRule {
        if m != nil {
                return m.Rules
        }
        return nil
}

// Response message for Bigtable.ReadModifyWriteRow.
type ReadModifyWriteRowResponse struct {
        // A Row containing the new contents of all cells modified by the request.
        Row *Row `protobuf:"bytes,1,opt,name=row" json:"row,omitempty"`
}

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

func (m *ReadModifyWriteRowResponse) GetRow() *Row {
        if m != nil {
                return m.Row
        }
        return nil
}

func init() {
        proto.RegisterType((*ReadRowsRequest)(nil), "google.bigtable.v2.ReadRowsRequest")
        proto.RegisterType((*ReadRowsResponse)(nil), "google.bigtable.v2.ReadRowsResponse")
        proto.RegisterType((*ReadRowsResponse_CellChunk)(nil), "google.bigtable.v2.ReadRowsResponse.CellChunk")
        proto.RegisterType((*SampleRowKeysRequest)(nil), "google.bigtable.v2.SampleRowKeysRequest")
        proto.RegisterType((*SampleRowKeysResponse)(nil), "google.bigtable.v2.SampleRowKeysResponse")
        proto.RegisterType((*MutateRowRequest)(nil), "google.bigtable.v2.MutateRowRequest")
        proto.RegisterType((*MutateRowResponse)(nil), "google.bigtable.v2.MutateRowResponse")
        proto.RegisterType((*MutateRowsRequest)(nil), "google.bigtable.v2.MutateRowsRequest")
        proto.RegisterType((*MutateRowsRequest_Entry)(nil), "google.bigtable.v2.MutateRowsRequest.Entry")
        proto.RegisterType((*MutateRowsResponse)(nil), "google.bigtable.v2.MutateRowsResponse")
        proto.RegisterType((*MutateRowsResponse_Entry)(nil), "google.bigtable.v2.MutateRowsResponse.Entry")
        proto.RegisterType((*CheckAndMutateRowRequest)(nil), "google.bigtable.v2.CheckAndMutateRowRequest")
        proto.RegisterType((*CheckAndMutateRowResponse)(nil), "google.bigtable.v2.CheckAndMutateRowResponse")
        proto.RegisterType((*ReadModifyWriteRowRequest)(nil), "google.bigtable.v2.ReadModifyWriteRowRequest")
        proto.RegisterType((*ReadModifyWriteRowResponse)(nil), "google.bigtable.v2.ReadModifyWriteRowResponse")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Bigtable service

type BigtableClient interface {
        // Streams back the contents of all requested rows in key order, optionally
        // applying the same Reader filter to each. Depending on their size,
        // rows and cells may be broken up across multiple responses, but
        // atomicity of each row will still be preserved. See the
        // ReadRowsResponse documentation for details.
        ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error)
        // Returns a sample of row keys in the table. The returned row keys will
        // delimit contiguous sections of the table of approximately equal size,
        // which can be used to break up the data for distributed tasks like
        // mapreduces.
        SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error)
        // Mutates a row atomically. Cells already present in the row are left
        // unchanged unless explicitly changed by `mutation`.
        MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error)
        // Mutates multiple rows in a batch. Each individual row is mutated
        // atomically as in MutateRow, but the entire batch is not executed
        // atomically.
        MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error)
        // Mutates a row atomically based on the output of a predicate Reader filter.
        CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error)
        // Modifies a row atomically. The method reads the latest existing timestamp
        // and value from the specified columns and writes a new entry based on
        // pre-defined read/modify/write rules. The new value for the timestamp is the
        // greater of the existing timestamp or the current server time. The method
        // returns the new contents of all modified cells.
        ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error)
}

type bigtableClient struct {
        cc *grpc.ClientConn
}

func NewBigtableClient(cc *grpc.ClientConn) BigtableClient {
        return &bigtableClient{cc}
}

func (c *bigtableClient) ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error) {
        stream, err := grpc.NewClientStream(ctx, &_Bigtable_serviceDesc.Streams[0], c.cc, "/google.bigtable.v2.Bigtable/ReadRows", opts...)
        if err != nil {
                return nil, err
        }
        x := &bigtableReadRowsClient{stream}
        if err := x.ClientStream.SendMsg(in); err != nil {
                return nil, err
        }
        if err := x.ClientStream.CloseSend(); err != nil {
                return nil, err
        }
        return x, nil
}

type Bigtable_ReadRowsClient interface {
        Recv() (*ReadRowsResponse, error)
        grpc.ClientStream
}

type bigtableReadRowsClient struct {
        grpc.ClientStream
}

func (x *bigtableReadRowsClient) Recv() (*ReadRowsResponse, error) {
        m := new(ReadRowsResponse)
        if err := x.ClientStream.RecvMsg(m); err != nil {
                return nil, err
        }
        return m, nil
}

func (c *bigtableClient) SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error) {
        stream, err := grpc.NewClientStream(ctx, &_Bigtable_serviceDesc.Streams[1], c.cc, "/google.bigtable.v2.Bigtable/SampleRowKeys", opts...)
        if err != nil {
                return nil, err
        }
        x := &bigtableSampleRowKeysClient{stream}
        if err := x.ClientStream.SendMsg(in); err != nil {
                return nil, err
        }
        if err := x.ClientStream.CloseSend(); err != nil {
                return nil, err
        }
        return x, nil
}

type Bigtable_SampleRowKeysClient interface {
        Recv() (*SampleRowKeysResponse, error)
        grpc.ClientStream
}

type bigtableSampleRowKeysClient struct {
        grpc.ClientStream
}

func (x *bigtableSampleRowKeysClient) Recv() (*SampleRowKeysResponse, error) {
        m := new(SampleRowKeysResponse)
        if err := x.ClientStream.RecvMsg(m); err != nil {
                return nil, err
        }
        return m, nil
}

func (c *bigtableClient) MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error) {
        out := new(MutateRowResponse)
        err := grpc.Invoke(ctx, "/google.bigtable.v2.Bigtable/MutateRow", in, out, c.cc, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *bigtableClient) MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error) {
        stream, err := grpc.NewClientStream(ctx, &_Bigtable_serviceDesc.Streams[2], c.cc, "/google.bigtable.v2.Bigtable/MutateRows", opts...)
        if err != nil {
                return nil, err
        }
        x := &bigtableMutateRowsClient{stream}
        if err := x.ClientStream.SendMsg(in); err != nil {
                return nil, err
        }
        if err := x.ClientStream.CloseSend(); err != nil {
                return nil, err
        }
        return x, nil
}

type Bigtable_MutateRowsClient interface {
        Recv() (*MutateRowsResponse, error)
        grpc.ClientStream
}

type bigtableMutateRowsClient struct {
        grpc.ClientStream
}

func (x *bigtableMutateRowsClient) Recv() (*MutateRowsResponse, error) {
        m := new(MutateRowsResponse)
        if err := x.ClientStream.RecvMsg(m); err != nil {
                return nil, err
        }
        return m, nil
}

func (c *bigtableClient) CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) {
        out := new(CheckAndMutateRowResponse)
        err := grpc.Invoke(ctx, "/google.bigtable.v2.Bigtable/CheckAndMutateRow", in, out, c.cc, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func (c *bigtableClient) ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error) {
        out := new(ReadModifyWriteRowResponse)
        err := grpc.Invoke(ctx, "/google.bigtable.v2.Bigtable/ReadModifyWriteRow", in, out, c.cc, opts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

// Server API for Bigtable service

type BigtableServer interface {
        // Streams back the contents of all requested rows in key order, optionally
        // applying the same Reader filter to each. Depending on their size,
        // rows and cells may be broken up across multiple responses, but
        // atomicity of each row will still be preserved. See the
        // ReadRowsResponse documentation for details.
        ReadRows(*ReadRowsRequest, Bigtable_ReadRowsServer) error
        // Returns a sample of row keys in the table. The returned row keys will
        // delimit contiguous sections of the table of approximately equal size,
        // which can be used to break up the data for distributed tasks like
        // mapreduces.
        SampleRowKeys(*SampleRowKeysRequest, Bigtable_SampleRowKeysServer) error
        // Mutates a row atomically. Cells already present in the row are left
        // unchanged unless explicitly changed by `mutation`.
        MutateRow(context.Context, *MutateRowRequest) (*MutateRowResponse, error)
        // Mutates multiple rows in a batch. Each individual row is mutated
        // atomically as in MutateRow, but the entire batch is not executed
        // atomically.
        MutateRows(*MutateRowsRequest, Bigtable_MutateRowsServer) error
        // Mutates a row atomically based on the output of a predicate Reader filter.
        CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error)
        // Modifies a row atomically. The method reads the latest existing timestamp
        // and value from the specified columns and writes a new entry based on
        // pre-defined read/modify/write rules. The new value for the timestamp is the
        // greater of the existing timestamp or the current server time. The method
        // returns the new contents of all modified cells.
        ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*ReadModifyWriteRowResponse, error)
}

func RegisterBigtableServer(s *grpc.Server, srv BigtableServer) {
        s.RegisterService(&_Bigtable_serviceDesc, srv)
}

func _Bigtable_ReadRows_Handler(srv interface{}, stream grpc.ServerStream) error {
        m := new(ReadRowsRequest)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return srv.(BigtableServer).ReadRows(m, &bigtableReadRowsServer{stream})
}

type Bigtable_ReadRowsServer interface {
        Send(*ReadRowsResponse) error
        grpc.ServerStream
}

type bigtableReadRowsServer struct {
        grpc.ServerStream
}

func (x *bigtableReadRowsServer) Send(m *ReadRowsResponse) error {
        return x.ServerStream.SendMsg(m)
}

func _Bigtable_SampleRowKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
        m := new(SampleRowKeysRequest)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return srv.(BigtableServer).SampleRowKeys(m, &bigtableSampleRowKeysServer{stream})
}

type Bigtable_SampleRowKeysServer interface {
        Send(*SampleRowKeysResponse) error
        grpc.ServerStream
}

type bigtableSampleRowKeysServer struct {
        grpc.ServerStream
}

func (x *bigtableSampleRowKeysServer) Send(m *SampleRowKeysResponse) error {
        return x.ServerStream.SendMsg(m)
}

func _Bigtable_MutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(MutateRowRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(BigtableServer).MutateRow(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/google.bigtable.v2.Bigtable/MutateRow",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(BigtableServer).MutateRow(ctx, req.(*MutateRowRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Bigtable_MutateRows_Handler(srv interface{}, stream grpc.ServerStream) error {
        m := new(MutateRowsRequest)
        if err := stream.RecvMsg(m); err != nil {
                return err
        }
        return srv.(BigtableServer).MutateRows(m, &bigtableMutateRowsServer{stream})
}

type Bigtable_MutateRowsServer interface {
        Send(*MutateRowsResponse) error
        grpc.ServerStream
}

type bigtableMutateRowsServer struct {
        grpc.ServerStream
}

func (x *bigtableMutateRowsServer) Send(m *MutateRowsResponse) error {
        return x.ServerStream.SendMsg(m)
}

func _Bigtable_CheckAndMutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(CheckAndMutateRowRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(BigtableServer).CheckAndMutateRow(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/google.bigtable.v2.Bigtable/CheckAndMutateRow",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(BigtableServer).CheckAndMutateRow(ctx, req.(*CheckAndMutateRowRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Bigtable_ReadModifyWriteRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(ReadModifyWriteRowRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(BigtableServer).ReadModifyWriteRow(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: "/google.bigtable.v2.Bigtable/ReadModifyWriteRow",
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(BigtableServer).ReadModifyWriteRow(ctx, req.(*ReadModifyWriteRowRequest))
        }
        return interceptor(ctx, in, info, handler)
}

var _Bigtable_serviceDesc = grpc.ServiceDesc{
        ServiceName: "google.bigtable.v2.Bigtable",
        HandlerType: (*BigtableServer)(nil),
        Methods: []grpc.MethodDesc{
                {
                        MethodName: "MutateRow",
                        Handler:    _Bigtable_MutateRow_Handler,
                },
                {
                        MethodName: "CheckAndMutateRow",
                        Handler:    _Bigtable_CheckAndMutateRow_Handler,
                },
                {
                        MethodName: "ReadModifyWriteRow",
                        Handler:    _Bigtable_ReadModifyWriteRow_Handler,
                },
        },
        Streams: []grpc.StreamDesc{
                {
                        StreamName:    "ReadRows",
                        Handler:       _Bigtable_ReadRows_Handler,
                        ServerStreams: true,
                },
                {
                        StreamName:    "SampleRowKeys",
                        Handler:       _Bigtable_SampleRowKeys_Handler,
                        ServerStreams: true,
                },
                {
                        StreamName:    "MutateRows",
                        Handler:       _Bigtable_MutateRows_Handler,
                        ServerStreams: true,
                },
        },
        Metadata: "google/bigtable/v2/bigtable.proto",
}

func init() { proto.RegisterFile("google/bigtable/v2/bigtable.proto", fileDescriptor0) }

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