mirrors/ceph-csi
1
0
Fork 0
mirror of https://github.com/ceph/ceph-csi.git synced 2025-06-14 18:53:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

vendor updates

Browse Source
This commit is contained in:
Serguei Bezverkhi
2018-03-06 17:33:18 -05:00
parent 4b3ebc171b
commit e9033989a0
5854 changed files with 248382 additions and 119809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
vendor/google.golang.org/genproto/googleapis/spanner/v1/keys.pb.go generated vendored
View File

@ -30,6 +30,11 @@ It has these top-level messages:
ListSessionsResponse
DeleteSessionRequest
ExecuteSqlRequest
PartitionOptions
PartitionQueryRequest
PartitionReadRequest
Partition
PartitionResponse
ReadRequest
BeginTransactionRequest
CommitRequest

2
vendor/google.golang.org/genproto/googleapis/spanner/v1/mutation.pb.go generated vendored
View File

@ -286,6 +286,8 @@ type Mutation_Delete struct {
// Required. The table whose rows will be deleted.
Table string `protobuf:"bytes,1,opt,name=table" json:"table,omitempty"`
// Required. The primary keys of the rows within [table][google.spanner.v1.Mutation.Delete.table] to delete.
// Delete is idempotent. The transaction will succeed even if some or all
// rows do not exist.
KeySet *KeySet `protobuf:"bytes,2,opt,name=key_set,json=keySet" json:"key_set,omitempty"`
}

598
vendor/google.golang.org/genproto/googleapis/spanner/v1/spanner.pb.go generated vendored
View File

@ -300,8 +300,14 @@ type ExecuteSqlRequest struct {
// request that yielded this token.
ResumeToken []byte `protobuf:"bytes,6,opt,name=resume_token,json=resumeToken,proto3" json:"resume_token,omitempty"`
// Used to control the amount of debugging information returned in
// [ResultSetStats][google.spanner.v1.ResultSetStats].
// [ResultSetStats][google.spanner.v1.ResultSetStats]. If [partition_token][google.spanner.v1.ExecuteSqlRequest.partition_token] is set, [query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] can only
// be set to [QueryMode.NORMAL][google.spanner.v1.ExecuteSqlRequest.QueryMode.NORMAL].
QueryMode ExecuteSqlRequest_QueryMode `protobuf:"varint,7,opt,name=query_mode,json=queryMode,enum=google.spanner.v1.ExecuteSqlRequest_QueryMode" json:"query_mode,omitempty"`
// If present, results will be restricted to the specified partition
// previously created using PartitionQuery(). There must be an exact
// match for the values of fields common to this message and the
// PartitionQueryRequest message used to create this partition_token.
PartitionToken []byte `protobuf:"bytes,8,opt,name=partition_token,json=partitionToken,proto3" json:"partition_token,omitempty"`
}
func (m *ExecuteSqlRequest) Reset() { *m = ExecuteSqlRequest{} }
@ -358,6 +364,267 @@ func (m *ExecuteSqlRequest) GetQueryMode() ExecuteSqlRequest_QueryMode {
return ExecuteSqlRequest_NORMAL
}
func (m *ExecuteSqlRequest) GetPartitionToken() []byte {
if m != nil {
return m.PartitionToken
}
return nil
}
// Options for a PartitionQueryRequest and
// PartitionReadRequest.
type PartitionOptions struct {
// The desired data size for each partition generated. The default for this
// option is currently 1 GiB. This is only a hint. The actual size of each
// partition may be smaller or larger than this size request.
PartitionSizeBytes int64 `protobuf:"varint,1,opt,name=partition_size_bytes,json=partitionSizeBytes" json:"partition_size_bytes,omitempty"`
// The desired maximum number of partitions to return. For example, this may
// be set to the number of workers available. The default for this option
// is currently 10,000. The maximum value is currently 200,000. This is only
// a hint. The actual number of partitions returned may be smaller or larger
// than this maximum count request.
MaxPartitions int64 `protobuf:"varint,2,opt,name=max_partitions,json=maxPartitions" json:"max_partitions,omitempty"`
}
func (m *PartitionOptions) Reset() { *m = PartitionOptions{} }
func (m *PartitionOptions) String() string { return proto.CompactTextString(m) }
func (*PartitionOptions) ProtoMessage() {}
func (*PartitionOptions) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{7} }
func (m *PartitionOptions) GetPartitionSizeBytes() int64 {
if m != nil {
return m.PartitionSizeBytes
}
return 0
}
func (m *PartitionOptions) GetMaxPartitions() int64 {
if m != nil {
return m.MaxPartitions
}
return 0
}
// The request for [PartitionQuery][google.spanner.v1.Spanner.PartitionQuery]
type PartitionQueryRequest struct {
// Required. The session used to create the partitions.
Session string `protobuf:"bytes,1,opt,name=session" json:"session,omitempty"`
// Read only snapshot transactions are supported, read/write and single use
// transactions are not.
Transaction *TransactionSelector `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
// The query request to generate partitions for. The request will fail if
// the query is not root partitionable. The query plan of a root
// partitionable query has a single distributed union operator. A distributed
// union operator conceptually divides one or more tables into multiple
// splits, remotely evaluates a subquery independently on each split, and
// then unions all results.
Sql string `protobuf:"bytes,3,opt,name=sql" json:"sql,omitempty"`
// The SQL query string can contain parameter placeholders. A parameter
// placeholder consists of `'@'` followed by the parameter
// name. Parameter names consist of any combination of letters,
// numbers, and underscores.
//
// Parameters can appear anywhere that a literal value is expected. The same
// parameter name can be used more than once, for example:
// `"WHERE id > @msg_id AND id < @msg_id + 100"`
//
// It is an error to execute an SQL query with unbound parameters.
//
// Parameter values are specified using `params`, which is a JSON
// object whose keys are parameter names, and whose values are the
// corresponding parameter values.
Params *google_protobuf1.Struct `protobuf:"bytes,4,opt,name=params" json:"params,omitempty"`
// It is not always possible for Cloud Spanner to infer the right SQL type
// from a JSON value. For example, values of type `BYTES` and values
// of type `STRING` both appear in [params][google.spanner.v1.PartitionQueryRequest.params] as JSON strings.
//
// In these cases, `param_types` can be used to specify the exact
// SQL type for some or all of the SQL query parameters. See the
// definition of [Type][google.spanner.v1.Type] for more information
// about SQL types.
ParamTypes map[string]*Type `protobuf:"bytes,5,rep,name=param_types,json=paramTypes" json:"param_types,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// Additional options that affect how many partitions are created.
PartitionOptions *PartitionOptions `protobuf:"bytes,6,opt,name=partition_options,json=partitionOptions" json:"partition_options,omitempty"`
}
func (m *PartitionQueryRequest) Reset() { *m = PartitionQueryRequest{} }
func (m *PartitionQueryRequest) String() string { return proto.CompactTextString(m) }
func (*PartitionQueryRequest) ProtoMessage() {}
func (*PartitionQueryRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{8} }
func (m *PartitionQueryRequest) GetSession() string {
if m != nil {
return m.Session
}
return ""
}
func (m *PartitionQueryRequest) GetTransaction() *TransactionSelector {
if m != nil {
return m.Transaction
}
return nil
}
func (m *PartitionQueryRequest) GetSql() string {
if m != nil {
return m.Sql
}
return ""
}
func (m *PartitionQueryRequest) GetParams() *google_protobuf1.Struct {
if m != nil {
return m.Params
}
return nil
}
func (m *PartitionQueryRequest) GetParamTypes() map[string]*Type {
if m != nil {
return m.ParamTypes
}
return nil
}
func (m *PartitionQueryRequest) GetPartitionOptions() *PartitionOptions {
if m != nil {
return m.PartitionOptions
}
return nil
}
// The request for [PartitionRead][google.spanner.v1.Spanner.PartitionRead]
type PartitionReadRequest struct {
// Required. The session used to create the partitions.
Session string `protobuf:"bytes,1,opt,name=session" json:"session,omitempty"`
// Read only snapshot transactions are supported, read/write and single use
// transactions are not.
Transaction *TransactionSelector `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
// Required. The name of the table in the database to be read.
Table string `protobuf:"bytes,3,opt,name=table" json:"table,omitempty"`
// If non-empty, the name of an index on [table][google.spanner.v1.PartitionReadRequest.table]. This index is
// used instead of the table primary key when interpreting [key_set][google.spanner.v1.PartitionReadRequest.key_set]
// and sorting result rows. See [key_set][google.spanner.v1.PartitionReadRequest.key_set] for further information.
Index string `protobuf:"bytes,4,opt,name=index" json:"index,omitempty"`
// The columns of [table][google.spanner.v1.PartitionReadRequest.table] to be returned for each row matching
// this request.
Columns []string `protobuf:"bytes,5,rep,name=columns" json:"columns,omitempty"`
// Required. `key_set` identifies the rows to be yielded. `key_set` names the
// primary keys of the rows in [table][google.spanner.v1.PartitionReadRequest.table] to be yielded, unless [index][google.spanner.v1.PartitionReadRequest.index]
// is present. If [index][google.spanner.v1.PartitionReadRequest.index] is present, then [key_set][google.spanner.v1.PartitionReadRequest.key_set] instead names
// index keys in [index][google.spanner.v1.PartitionReadRequest.index].
//
// It is not an error for the `key_set` to name rows that do not
// exist in the database. Read yields nothing for nonexistent rows.
KeySet *KeySet `protobuf:"bytes,6,opt,name=key_set,json=keySet" json:"key_set,omitempty"`
// Additional options that affect how many partitions are created.
PartitionOptions *PartitionOptions `protobuf:"bytes,9,opt,name=partition_options,json=partitionOptions" json:"partition_options,omitempty"`
}
func (m *PartitionReadRequest) Reset() { *m = PartitionReadRequest{} }
func (m *PartitionReadRequest) String() string { return proto.CompactTextString(m) }
func (*PartitionReadRequest) ProtoMessage() {}
func (*PartitionReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{9} }
func (m *PartitionReadRequest) GetSession() string {
if m != nil {
return m.Session
}
return ""
}
func (m *PartitionReadRequest) GetTransaction() *TransactionSelector {
if m != nil {
return m.Transaction
}
return nil
}
func (m *PartitionReadRequest) GetTable() string {
if m != nil {
return m.Table
}
return ""
}
func (m *PartitionReadRequest) GetIndex() string {
if m != nil {
return m.Index
}
return ""
}
func (m *PartitionReadRequest) GetColumns() []string {
if m != nil {
return m.Columns
}
return nil
}
func (m *PartitionReadRequest) GetKeySet() *KeySet {
if m != nil {
return m.KeySet
}
return nil
}
func (m *PartitionReadRequest) GetPartitionOptions() *PartitionOptions {
if m != nil {
return m.PartitionOptions
}
return nil
}
// Information returned for each partition returned in a
// PartitionResponse.
type Partition struct {
// This token can be passed to Read, StreamingRead, ExecuteSql, or
// ExecuteStreamingSql requests to restrict the results to those identified by
// this partition token.
PartitionToken []byte `protobuf:"bytes,1,opt,name=partition_token,json=partitionToken,proto3" json:"partition_token,omitempty"`
}
func (m *Partition) Reset() { *m = Partition{} }
func (m *Partition) String() string { return proto.CompactTextString(m) }
func (*Partition) ProtoMessage() {}
func (*Partition) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{10} }
func (m *Partition) GetPartitionToken() []byte {
if m != nil {
return m.PartitionToken
}
return nil
}
// The response for [PartitionQuery][google.spanner.v1.Spanner.PartitionQuery]
// or [PartitionRead][google.spanner.v1.Spanner.PartitionRead]
type PartitionResponse struct {
// Partitions created by this request.
Partitions []*Partition `protobuf:"bytes,1,rep,name=partitions" json:"partitions,omitempty"`
// Transaction created by this request.
Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
}
func (m *PartitionResponse) Reset() { *m = PartitionResponse{} }
func (m *PartitionResponse) String() string { return proto.CompactTextString(m) }
func (*PartitionResponse) ProtoMessage() {}
func (*PartitionResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{11} }
func (m *PartitionResponse) GetPartitions() []*Partition {
if m != nil {
return m.Partitions
}
return nil
}
func (m *PartitionResponse) GetTransaction() *Transaction {
if m != nil {
return m.Transaction
}
return nil
}
// The request for [Read][google.spanner.v1.Spanner.Read] and
// [StreamingRead][google.spanner.v1.Spanner.StreamingRead].
type ReadRequest struct {
@ -380,14 +647,17 @@ type ReadRequest struct {
// is present. If [index][google.spanner.v1.ReadRequest.index] is present, then [key_set][google.spanner.v1.ReadRequest.key_set] instead names
// index keys in [index][google.spanner.v1.ReadRequest.index].
//
// Rows are yielded in table primary key order (if [index][google.spanner.v1.ReadRequest.index] is empty)
// or index key order (if [index][google.spanner.v1.ReadRequest.index] is non-empty).
// If the [partition_token][google.spanner.v1.ReadRequest.partition_token] field is empty, rows are yielded
// in table primary key order (if [index][google.spanner.v1.ReadRequest.index] is empty) or index key order
// (if [index][google.spanner.v1.ReadRequest.index] is non-empty). If the [partition_token][google.spanner.v1.ReadRequest.partition_token] field is not
// empty, rows will be yielded in an unspecified order.
//
// It is not an error for the `key_set` to name rows that do not
// exist in the database. Read yields nothing for nonexistent rows.
KeySet *KeySet `protobuf:"bytes,6,opt,name=key_set,json=keySet" json:"key_set,omitempty"`
// If greater than zero, only the first `limit` rows are yielded. If `limit`
// is zero, the default is no limit.
// is zero, the default is no limit. A limit cannot be specified if
// `partition_token` is set.
Limit int64 `protobuf:"varint,8,opt,name=limit" json:"limit,omitempty"`
// If this request is resuming a previously interrupted read,
// `resume_token` should be copied from the last
@ -396,12 +666,17 @@ type ReadRequest struct {
// rest of the request parameters must exactly match the request
// that yielded this token.
ResumeToken []byte `protobuf:"bytes,9,opt,name=resume_token,json=resumeToken,proto3" json:"resume_token,omitempty"`
// If present, results will be restricted to the specified partition
// previously created using PartitionRead(). There must be an exact
// match for the values of fields common to this message and the
// PartitionReadRequest message used to create this partition_token.
PartitionToken []byte `protobuf:"bytes,10,opt,name=partition_token,json=partitionToken,proto3" json:"partition_token,omitempty"`
}
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRequest) ProtoMessage() {}
func (*ReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{7} }
func (*ReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{12} }
func (m *ReadRequest) GetSession() string {
if m != nil {
@ -459,6 +734,13 @@ func (m *ReadRequest) GetResumeToken() []byte {
return nil
}
func (m *ReadRequest) GetPartitionToken() []byte {
if m != nil {
return m.PartitionToken
}
return nil
}
// The request for [BeginTransaction][google.spanner.v1.Spanner.BeginTransaction].
type BeginTransactionRequest struct {
// Required. The session in which the transaction runs.
@ -470,7 +752,7 @@ type BeginTransactionRequest struct {
func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} }
func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
func (*BeginTransactionRequest) ProtoMessage() {}
func (*BeginTransactionRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{8} }
func (*BeginTransactionRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{13} }
func (m *BeginTransactionRequest) GetSession() string {
if m != nil {
@ -505,7 +787,7 @@ type CommitRequest struct {
func (m *CommitRequest) Reset() { *m = CommitRequest{} }
func (m *CommitRequest) String() string { return proto.CompactTextString(m) }
func (*CommitRequest) ProtoMessage() {}
func (*CommitRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{9} }
func (*CommitRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{14} }
type isCommitRequest_Transaction interface {
isCommitRequest_Transaction()
@ -635,7 +917,7 @@ type CommitResponse struct {
func (m *CommitResponse) Reset() { *m = CommitResponse{} }
func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
func (*CommitResponse) ProtoMessage() {}
func (*CommitResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{10} }
func (*CommitResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{15} }
func (m *CommitResponse) GetCommitTimestamp() *google_protobuf3.Timestamp {
if m != nil {
@ -655,7 +937,7 @@ type RollbackRequest struct {
func (m *RollbackRequest) Reset() { *m = RollbackRequest{} }
func (m *RollbackRequest) String() string { return proto.CompactTextString(m) }
func (*RollbackRequest) ProtoMessage() {}
func (*RollbackRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{11} }
func (*RollbackRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{16} }
func (m *RollbackRequest) GetSession() string {
if m != nil {
@ -679,6 +961,11 @@ func init() {
proto.RegisterType((*ListSessionsResponse)(nil), "google.spanner.v1.ListSessionsResponse")
proto.RegisterType((*DeleteSessionRequest)(nil), "google.spanner.v1.DeleteSessionRequest")
proto.RegisterType((*ExecuteSqlRequest)(nil), "google.spanner.v1.ExecuteSqlRequest")
proto.RegisterType((*PartitionOptions)(nil), "google.spanner.v1.PartitionOptions")
proto.RegisterType((*PartitionQueryRequest)(nil), "google.spanner.v1.PartitionQueryRequest")
proto.RegisterType((*PartitionReadRequest)(nil), "google.spanner.v1.PartitionReadRequest")
proto.RegisterType((*Partition)(nil), "google.spanner.v1.Partition")
proto.RegisterType((*PartitionResponse)(nil), "google.spanner.v1.PartitionResponse")
proto.RegisterType((*ReadRequest)(nil), "google.spanner.v1.ReadRequest")
proto.RegisterType((*BeginTransactionRequest)(nil), "google.spanner.v1.BeginTransactionRequest")
proto.RegisterType((*CommitRequest)(nil), "google.spanner.v1.CommitRequest")
@ -787,6 +1074,24 @@ type SpannerClient interface {
// transaction was already aborted, or the transaction is not
// found. `Rollback` never returns `ABORTED`.
Rollback(ctx context.Context, in *RollbackRequest, opts ...grpc.CallOption) (*google_protobuf4.Empty, error)
// Creates a set of partition tokens that can be used to execute a query
// operation in parallel. Each of the returned partition tokens can be used
// by [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql] to specify a subset
// of the query result to read. The same session and read-only transaction
// must be used by the PartitionQueryRequest used to create the
// partition tokens and the ExecuteSqlRequests that use the partition tokens.
// Partition tokens become invalid when the session used to create them
// is deleted or begins a new transaction.
PartitionQuery(ctx context.Context, in *PartitionQueryRequest, opts ...grpc.CallOption) (*PartitionResponse, error)
// Creates a set of partition tokens that can be used to execute a read
// operation in parallel. Each of the returned partition tokens can be used
// by [StreamingRead][google.spanner.v1.Spanner.StreamingRead] to specify a subset of the read
// result to read. The same session and read-only transaction must be used by
// the PartitionReadRequest used to create the partition tokens and the
// ReadRequests that use the partition tokens.
// Partition tokens become invalid when the session used to create them
// is deleted or begins a new transaction.
PartitionRead(ctx context.Context, in *PartitionReadRequest, opts ...grpc.CallOption) (*PartitionResponse, error)
}
type spannerClient struct {
@ -942,6 +1247,24 @@ func (c *spannerClient) Rollback(ctx context.Context, in *RollbackRequest, opts
return out, nil
}
func (c *spannerClient) PartitionQuery(ctx context.Context, in *PartitionQueryRequest, opts ...grpc.CallOption) (*PartitionResponse, error) {
out := new(PartitionResponse)
err := grpc.Invoke(ctx, "/google.spanner.v1.Spanner/PartitionQuery", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *spannerClient) PartitionRead(ctx context.Context, in *PartitionReadRequest, opts ...grpc.CallOption) (*PartitionResponse, error) {
out := new(PartitionResponse)
err := grpc.Invoke(ctx, "/google.spanner.v1.Spanner/PartitionRead", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Spanner service
type SpannerServer interface {
@ -1034,6 +1357,24 @@ type SpannerServer interface {
// transaction was already aborted, or the transaction is not
// found. `Rollback` never returns `ABORTED`.
Rollback(context.Context, *RollbackRequest) (*google_protobuf4.Empty, error)
// Creates a set of partition tokens that can be used to execute a query
// operation in parallel. Each of the returned partition tokens can be used
// by [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql] to specify a subset
// of the query result to read. The same session and read-only transaction
// must be used by the PartitionQueryRequest used to create the
// partition tokens and the ExecuteSqlRequests that use the partition tokens.
// Partition tokens become invalid when the session used to create them
// is deleted or begins a new transaction.
PartitionQuery(context.Context, *PartitionQueryRequest) (*PartitionResponse, error)
// Creates a set of partition tokens that can be used to execute a read
// operation in parallel. Each of the returned partition tokens can be used
// by [StreamingRead][google.spanner.v1.Spanner.StreamingRead] to specify a subset of the read
// result to read. The same session and read-only transaction must be used by
// the PartitionReadRequest used to create the partition tokens and the
// ReadRequests that use the partition tokens.
// Partition tokens become invalid when the session used to create them
// is deleted or begins a new transaction.
PartitionRead(context.Context, *PartitionReadRequest) (*PartitionResponse, error)
}
func RegisterSpannerServer(s *grpc.Server, srv SpannerServer) {
@ -1244,6 +1585,42 @@ func _Spanner_Rollback_Handler(srv interface{}, ctx context.Context, dec func(in
return interceptor(ctx, in, info, handler)
}
func _Spanner_PartitionQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PartitionQueryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SpannerServer).PartitionQuery(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.spanner.v1.Spanner/PartitionQuery",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SpannerServer).PartitionQuery(ctx, req.(*PartitionQueryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Spanner_PartitionRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PartitionReadRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SpannerServer).PartitionRead(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.spanner.v1.Spanner/PartitionRead",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SpannerServer).PartitionRead(ctx, req.(*PartitionReadRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Spanner_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.spanner.v1.Spanner",
HandlerType: (*SpannerServer)(nil),
@ -1284,6 +1661,14 @@ var _Spanner_serviceDesc = grpc.ServiceDesc{
MethodName: "Rollback",
Handler: _Spanner_Rollback_Handler,
},
{
MethodName: "PartitionQuery",
Handler: _Spanner_PartitionQuery_Handler,
},
{
MethodName: "PartitionRead",
Handler: _Spanner_PartitionRead_Handler,
},
},
Streams: []grpc.StreamDesc{
{
@ -1303,94 +1688,109 @@ var _Spanner_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("google/spanner/v1/spanner.proto", fileDescriptor4) }
var fileDescriptor4 = []byte{
// 1416 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4f, 0x6f, 0x13, 0x47,
0x14, 0x67, 0x9d, 0xc4, 0x89, 0x9f, 0xf3, 0x8f, 0x21, 0x0d, 0xc6, 0x50, 0x30, 0x4b, 0x21, 0x91,
0xa5, 0xda, 0x4d, 0x8a, 0x2a, 0x30, 0x6d, 0x81, 0x80, 0x81, 0x08, 0x87, 0x98, 0x75, 0x00, 0x09,
0x51, 0x59, 0x63, 0x7b, 0x70, 0xb7, 0xd9, 0x7f, 0xd9, 0x19, 0x47, 0x31, 0x15, 0x97, 0x4a, 0x3d,
0xf5, 0xd2, 0x52, 0x55, 0x3d, 0xb4, 0xb7, 0xf6, 0x54, 0x71, 0xef, 0xad, 0x1f, 0xa0, 0xd7, 0x7e,
0x85, 0x7e, 0x8b, 0x5e, 0xaa, 0xf9, 0xe7, 0x6c, 0xec, 0xc5, 0x09, 0x72, 0xd5, 0x93, 0x67, 0xe6,
0xbd, 0x79, 0xef, 0xb7, 0xbf, 0xf7, 0x66, 0x7e, 0x63, 0x38, 0xd7, 0xf6, 0xfd, 0xb6, 0x43, 0x8a,
0x34, 0xc0, 0x9e, 0x47, 0xc2, 0xe2, 0xee, 0x8a, 0x1e, 0x16, 0x82, 0xd0, 0x67, 0x3e, 0x3a, 0x2e,
0x1d, 0x0a, 0x7a, 0x75, 0x77, 0x25, 0x7b, 0x46, 0xed, 0xc1, 0x81, 0x5d, 0xc4, 0x9e, 0xe7, 0x33,
0xcc, 0x6c, 0xdf, 0xa3, 0x72, 0x43, 0xf6, 0xb4, 0xb2, 0x8a, 0x59, 0xa3, 0xf3, 0xbc, 0x48, 0xdc,
0x80, 0x75, 0x95, 0xf1, 0x4c, 0xbf, 0x91, 0xb2, 0xb0, 0xd3, 0x64, 0xca, 0x7a, 0xae, 0xdf, 0xca,
0x6c, 0x97, 0x50, 0x86, 0xdd, 0xa0, 0x6f, 0x7b, 0x04, 0xed, 0x36, 0xe9, 0xea, 0xcc, 0xb9, 0x41,
0xab, 0xdb, 0x91, 0xe0, 0x94, 0x87, 0x39, 0xe8, 0x11, 0x12, 0xda, 0x71, 0x58, 0x9d, 0x12, 0x0d,
0xe2, 0xc2, 0xa0, 0x0f, 0x0b, 0xb1, 0x47, 0x71, 0x33, 0x12, 0x28, 0x06, 0x08, 0xeb, 0x06, 0x44,
0x5a, 0xcd, 0xcf, 0x61, 0xe1, 0x56, 0x48, 0x30, 0x23, 0x35, 0x42, 0xa9, 0xed, 0x7b, 0x16, 0xd9,
0xe9, 0x10, 0xca, 0x50, 0x16, 0xa6, 0x5a, 0x98, 0xe1, 0x06, 0xa6, 0x24, 0x63, 0xe4, 0x8c, 0xe5,
0x94, 0xd5, 0x9b, 0xa3, 0xcb, 0x30, 0x49, 0xa5, 0x77, 0x26, 0x91, 0x33, 0x96, 0xd3, 0xab, 0xd9,
0xc2, 0x00, 0xf3, 0x05, 0x1d, 0x4f, 0xbb, 0x9a, 0xaf, 0x13, 0x30, 0xa9, 0x16, 0x11, 0x82, 0x71,
0x0f, 0xbb, 0x3a, 0xb2, 0x18, 0xa3, 0x4f, 0x21, 0xe9, 0xe0, 0x06, 0x71, 0x68, 0x26, 0x91, 0x1b,
0x5b, 0x4e, 0xaf, 0x5e, 0x7a, 0x73, 0xd0, 0x42, 0x45, 0x38, 0x96, 0x3d, 0x16, 0x76, 0x2d, 0xb5,
0x0b, 0x5d, 0x83, 0x74, 0x53, 0x7c, 0x49, 0x9d, 0x97, 0x22, 0x33, 0x76, 0x10, 0x99, 0xae, 0x53,
0x61, 0x4b, 0xd7, 0xc9, 0x02, 0xe9, 0xce, 0x17, 0xd0, 0x23, 0x38, 0x85, 0x83, 0x20, 0xf4, 0xf7,
0x6c, 0x97, 0x47, 0x70, 0x30, 0x65, 0xf5, 0x0e, 0x55, 0xa1, 0xc6, 0x0f, 0x0d, 0xb5, 0x18, 0xd9,
0x5c, 0xc1, 0x94, 0x3d, 0xa2, 0x22, 0x6c, 0xf6, 0x2a, 0xa4, 0x23, 0x50, 0xd1, 0x3c, 0x8c, 0x6d,
0x93, 0xae, 0xfa, 0x6a, 0x3e, 0x44, 0x0b, 0x30, 0xb1, 0x8b, 0x9d, 0x0e, 0x11, 0x44, 0xa6, 0x2c,
0x39, 0x29, 0x25, 0xae, 0x18, 0xe6, 0x12, 0x1c, 0xbf, 0x4b, 0x58, 0x5f, 0x55, 0x62, 0x78, 0x33,
0xbf, 0x36, 0xe0, 0x44, 0xc5, 0xa6, 0xda, 0x95, 0x1e, 0xa5, 0x82, 0xa7, 0x21, 0x15, 0xe0, 0x36,
0xa9, 0x53, 0xfb, 0x85, 0x4c, 0x3d, 0x61, 0x4d, 0xf1, 0x85, 0x9a, 0xfd, 0x82, 0xa0, 0x77, 0x01,
0x84, 0x91, 0xf9, 0xdb, 0xc4, 0x13, 0x3c, 0xa6, 0x2c, 0xe1, 0xbe, 0xc5, 0x17, 0xd0, 0x22, 0x24,
0x9f, 0xdb, 0x0e, 0x23, 0xa1, 0xe0, 0x25, 0x65, 0xa9, 0x99, 0xb9, 0x0b, 0x0b, 0x07, 0x61, 0xd0,
0xc0, 0xf7, 0x28, 0x41, 0x1f, 0xc1, 0x94, 0x6a, 0x01, 0x9a, 0x31, 0x44, 0x65, 0x87, 0xb5, 0x4b,
0xcf, 0x17, 0x5d, 0x82, 0x39, 0x8f, 0xec, 0xb1, 0x7a, 0x04, 0x8b, 0x24, 0x69, 0x86, 0x2f, 0x57,
0x35, 0x1e, 0x33, 0x0f, 0x0b, 0xb7, 0x89, 0x43, 0x06, 0x3a, 0x38, 0x8e, 0xab, 0x6f, 0xc6, 0xe1,
0x78, 0x79, 0x8f, 0x34, 0x3b, 0x8c, 0xd4, 0x76, 0x1c, 0xed, 0x99, 0xd9, 0xef, 0x67, 0xe9, 0xac,
0xa7, 0xe8, 0x1e, 0xa4, 0x23, 0x07, 0x4a, 0x75, 0x7b, 0x5c, 0x63, 0x6e, 0xed, 0x7b, 0xd5, 0x88,
0x43, 0x9a, 0xcc, 0x0f, 0xad, 0xe8, 0x56, 0x5e, 0x7a, 0xba, 0xe3, 0x28, 0x36, 0xf9, 0x10, 0x15,
0x21, 0x19, 0xe0, 0x10, 0xbb, 0x54, 0xf5, 0xd7, 0xc9, 0x81, 0xfe, 0xaa, 0x89, 0x0b, 0xc7, 0x52,
0x6e, 0xe8, 0x11, 0xa4, 0xc5, 0xa8, 0xce, 0x8f, 0x2f, 0xcd, 0x4c, 0x08, 0x2e, 0x2f, 0xc7, 0x80,
0x19, 0xf8, 0xc2, 0x42, 0x95, 0xef, 0xdb, 0xe2, 0xdb, 0xe4, 0x99, 0x81, 0xa0, 0xb7, 0x80, 0xce,
0xc3, 0x34, 0xbf, 0x58, 0x5c, 0x4d, 0x72, 0x32, 0x67, 0x2c, 0x4f, 0x5b, 0x69, 0xb9, 0x26, 0x4b,
0xbe, 0x01, 0xb0, 0xd3, 0x21, 0x61, 0xb7, 0xee, 0xfa, 0x2d, 0x92, 0x99, 0xcc, 0x19, 0xcb, 0xb3,
0xab, 0x85, 0x23, 0x25, 0x7e, 0xc8, 0xb7, 0x6d, 0xf8, 0x2d, 0x62, 0xa5, 0x76, 0xf4, 0x30, 0xfb,
0x18, 0xe6, 0xfa, 0x00, 0xc5, 0x9c, 0x8c, 0xf7, 0xa3, 0x27, 0x23, 0xc2, 0x4e, 0x94, 0xf4, 0x6e,
0x40, 0xa2, 0x47, 0xa6, 0x00, 0xa9, 0x5e, 0x3e, 0x04, 0x90, 0x7c, 0xb0, 0x69, 0x6d, 0xdc, 0xac,
0xcc, 0x1f, 0x43, 0x53, 0x30, 0x5e, 0xad, 0xdc, 0x7c, 0x30, 0x6f, 0xa0, 0x34, 0x4c, 0x56, 0xad,
0xcd, 0x3b, 0xeb, 0x95, 0xf2, 0x7c, 0xc2, 0xfc, 0x35, 0x01, 0x69, 0x8b, 0xe0, 0xd6, 0xff, 0xd9,
0x07, 0x0b, 0x30, 0xc1, 0x70, 0xc3, 0x21, 0xaa, 0x13, 0xe4, 0x84, 0xaf, 0xda, 0x5e, 0x8b, 0xec,
0xa9, 0x23, 0x25, 0x27, 0x1c, 0x4f, 0xd3, 0x77, 0x3a, 0xae, 0x27, 0x8b, 0x9d, 0xb2, 0xf4, 0x14,
0xad, 0xc2, 0xe4, 0x36, 0xe9, 0x72, 0x25, 0x10, 0xe5, 0x4a, 0xaf, 0x9e, 0x8a, 0xc1, 0x72, 0x9f,
0x74, 0x6b, 0x84, 0x59, 0xc9, 0x6d, 0xf1, 0xcb, 0x73, 0x38, 0xb6, 0x6b, 0xb3, 0xcc, 0x54, 0xce,
0x58, 0x1e, 0xb3, 0xe4, 0x64, 0xa0, 0xfa, 0xa9, 0x81, 0xea, 0x9b, 0x0c, 0x4e, 0xae, 0x91, 0xb6,
0xed, 0x45, 0xbe, 0xed, 0x70, 0xc6, 0xae, 0xc3, 0xa4, 0x1f, 0x08, 0xad, 0x55, 0x6c, 0x5d, 0x1c,
0xce, 0xd6, 0xa6, 0x74, 0xb6, 0xf4, 0x2e, 0xf3, 0x1f, 0x03, 0x66, 0x6e, 0xf9, 0xae, 0x6b, 0xb3,
0xc3, 0x93, 0x2d, 0xc1, 0x6c, 0x84, 0xe3, 0xba, 0xdd, 0x12, 0x39, 0xa7, 0xef, 0x1d, 0xb3, 0x66,
0x22, 0xeb, 0xeb, 0x2d, 0xf4, 0x19, 0x2c, 0x52, 0xdb, 0x6b, 0x3b, 0x44, 0x5e, 0xee, 0x91, 0x92,
0x8e, 0xbd, 0x05, 0xc8, 0x7b, 0xc7, 0xac, 0x05, 0x19, 0x86, 0xdf, 0xf3, 0x91, 0xe2, 0x5e, 0x85,
0x94, 0x56, 0x71, 0x7e, 0xaa, 0xf9, 0xf9, 0x3c, 0x1d, 0x13, 0x71, 0x43, 0xf9, 0x58, 0xfb, 0xde,
0x6b, 0x33, 0x07, 0x3a, 0xcc, 0x7c, 0x02, 0xb3, 0xfa, 0xe3, 0xd5, 0x35, 0x5a, 0x86, 0xf9, 0xa6,
0x58, 0xa9, 0xf7, 0x5e, 0x1a, 0x82, 0x86, 0xe1, 0xc2, 0x34, 0x27, 0xf7, 0xf4, 0x16, 0x4c, 0x0b,
0xe6, 0x2c, 0xdf, 0x71, 0x1a, 0xb8, 0xb9, 0x7d, 0x38, 0xaf, 0x17, 0xe3, 0x79, 0xed, 0x63, 0x75,
0xf5, 0xd5, 0x2c, 0x4c, 0xd6, 0xe4, 0xe7, 0xa1, 0x9f, 0x78, 0xd9, 0xa2, 0x0f, 0x0a, 0xb4, 0x14,
0xc3, 0x40, 0xdc, 0x93, 0x23, 0x3b, 0x44, 0x16, 0xcc, 0xf2, 0x57, 0x7f, 0xfd, 0xfd, 0x7d, 0xe2,
0xba, 0x59, 0xe2, 0xcf, 0x97, 0x2f, 0xb5, 0x8e, 0x7d, 0x12, 0x84, 0xfe, 0x17, 0xa4, 0xc9, 0x68,
0x31, 0x5f, 0xb4, 0x3d, 0xca, 0xb0, 0xd7, 0x24, 0x7c, 0xac, 0xed, 0xb4, 0x98, 0x7f, 0x59, 0xd4,
0x82, 0x52, 0x32, 0xf2, 0xe8, 0x5b, 0x03, 0x60, 0x5f, 0x55, 0xd1, 0x7b, 0x31, 0x19, 0x07, 0x44,
0x77, 0x28, 0xae, 0x1b, 0x02, 0x57, 0x09, 0x5d, 0x11, 0xb8, 0xb8, 0xc6, 0x1c, 0x01, 0x53, 0x0f,
0x52, 0x31, 0xff, 0x12, 0xfd, 0x62, 0xc0, 0x74, 0x54, 0x37, 0x51, 0xdc, 0xb5, 0x12, 0xa3, 0xef,
0xd9, 0xa5, 0x43, 0xfd, 0x64, 0xe7, 0x98, 0x6b, 0x02, 0xe3, 0xc7, 0x68, 0x04, 0xee, 0xd0, 0x2b,
0x03, 0x66, 0x0e, 0xa8, 0x6c, 0x6c, 0x59, 0xe3, 0x74, 0x38, 0xbb, 0x38, 0xd0, 0x9e, 0x65, 0xfe,
0xca, 0xd6, 0xd4, 0xe5, 0x47, 0xa2, 0x0e, 0xf6, 0x25, 0x27, 0xb6, 0x9a, 0x03, 0x8a, 0x94, 0x3d,
0x13, 0xe3, 0x65, 0x89, 0x87, 0x75, 0x8d, 0x30, 0xf3, 0xa1, 0x00, 0x75, 0xdf, 0xbc, 0x23, 0x40,
0xa9, 0x64, 0x6f, 0x89, 0xab, 0x44, 0x7a, 0x49, 0x79, 0xcf, 0xfd, 0x61, 0xc0, 0x09, 0x0d, 0x83,
0x85, 0x04, 0xbb, 0xb6, 0xd7, 0x3e, 0x3a, 0xdc, 0x0b, 0x31, 0x5e, 0x55, 0x1c, 0x32, 0x1b, 0x3b,
0xfb, 0xa8, 0x9f, 0x0a, 0xd4, 0x5b, 0xe6, 0xe6, 0x7f, 0x81, 0x3a, 0x82, 0xb1, 0x64, 0xe4, 0x3f,
0x30, 0xd0, 0x77, 0x06, 0x8c, 0x73, 0x99, 0x44, 0x67, 0x63, 0xa9, 0xeb, 0xe9, 0xe7, 0x21, 0xd4,
0xde, 0x17, 0x20, 0xcb, 0xe6, 0x8d, 0x51, 0x40, 0x86, 0x04, 0xb7, 0x38, 0xa9, 0xaf, 0x0d, 0x98,
0xe9, 0x21, 0x3d, 0x12, 0xb8, 0x23, 0x11, 0xb9, 0x25, 0x30, 0x3e, 0x30, 0xd7, 0x47, 0xc1, 0x48,
0xa3, 0xb8, 0x24, 0x85, 0xbf, 0x1b, 0x30, 0xdf, 0xaf, 0xa1, 0x28, 0x1f, 0x83, 0xe8, 0x0d, 0x42,
0x9b, 0x3d, 0x3b, 0x5c, 0x98, 0xcc, 0x27, 0x02, 0xf8, 0x43, 0xb3, 0x32, 0x0a, 0xf0, 0x46, 0x5f,
0x72, 0x4e, 0xf4, 0xcf, 0x06, 0x24, 0xa5, 0x12, 0xa1, 0x5c, 0xdc, 0x45, 0x1e, 0x55, 0xe8, 0xec,
0xf9, 0x21, 0x1e, 0xea, 0x32, 0xda, 0x10, 0x40, 0xef, 0x9a, 0x6b, 0xa3, 0x00, 0x95, 0xa2, 0xc6,
0xe1, 0xfd, 0x68, 0xc0, 0x94, 0xd6, 0x33, 0x64, 0xc6, 0xb5, 0xc0, 0x41, 0xb1, 0x7b, 0xe3, 0x6d,
0xb4, 0x29, 0x70, 0xad, 0x9b, 0xb7, 0x47, 0xea, 0x4e, 0x95, 0xac, 0x64, 0xe4, 0xd7, 0x7e, 0x30,
0xe0, 0x9d, 0xa6, 0xef, 0x0e, 0x42, 0x5a, 0x9b, 0x56, 0x5a, 0x59, 0xe5, 0x08, 0xaa, 0xc6, 0xd3,
0x2b, 0xca, 0xa5, 0xed, 0x3b, 0xd8, 0x6b, 0x17, 0xfc, 0xb0, 0x5d, 0x6c, 0x13, 0x4f, 0xe0, 0x2b,
0x4a, 0x13, 0x0e, 0x6c, 0x1a, 0xf9, 0xff, 0x7e, 0x4d, 0x0d, 0x7f, 0x4b, 0x9c, 0xbc, 0x2b, 0xb7,
0xde, 0x72, 0xfc, 0x4e, 0xab, 0xa0, 0xe2, 0x16, 0x1e, 0xaf, 0xfc, 0xa9, 0x2d, 0xcf, 0x84, 0xe5,
0x99, 0xb2, 0x3c, 0x7b, 0xbc, 0xd2, 0x48, 0x8a, 0xc0, 0x1f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff,
0x57, 0x35, 0x15, 0x7f, 0x4e, 0x11, 0x00, 0x00,
// 1657 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0xdd, 0x6f, 0x53, 0xc9,
0x15, 0xe7, 0xda, 0x89, 0x13, 0x1f, 0xc7, 0x89, 0x33, 0x98, 0x60, 0x0c, 0x85, 0x70, 0xf9, 0x48,
0x64, 0xa9, 0x36, 0x49, 0x51, 0x15, 0x02, 0x2d, 0x10, 0x08, 0x90, 0x92, 0x10, 0x73, 0x9d, 0x80,
0x8a, 0xa8, 0xac, 0xb1, 0x3d, 0xb8, 0xb7, 0xb9, 0x5f, 0xb9, 0x33, 0x8e, 0x62, 0x2a, 0x5e, 0x5a,
0xf5, 0xbd, 0x2d, 0xaa, 0xfa, 0xd0, 0xbe, 0xed, 0xdb, 0x8a, 0x47, 0x24, 0xde, 0xf6, 0x65, 0xa5,
0x7d, 0x58, 0x69, 0x9f, 0xf6, 0x5f, 0xd8, 0xff, 0x62, 0x5f, 0x56, 0x33, 0xf7, 0xc3, 0xd7, 0xf6,
0xc4, 0x31, 0x32, 0xbb, 0xd2, 0x6a, 0x9f, 0x3c, 0x33, 0xe7, 0xcc, 0x9c, 0xdf, 0xfd, 0x9d, 0x33,
0x73, 0xce, 0x31, 0x5c, 0x68, 0xda, 0x76, 0xd3, 0x20, 0x25, 0xea, 0x60, 0xcb, 0x22, 0x6e, 0xe9,
0x60, 0x29, 0x18, 0x16, 0x1d, 0xd7, 0x66, 0x36, 0x9a, 0xf5, 0x14, 0x8a, 0xc1, 0xea, 0xc1, 0x52,
0xfe, 0x9c, 0xbf, 0x07, 0x3b, 0x7a, 0x09, 0x5b, 0x96, 0xcd, 0x30, 0xd3, 0x6d, 0x8b, 0x7a, 0x1b,
0xf2, 0x67, 0x7d, 0xa9, 0x98, 0xd5, 0x5a, 0xaf, 0x4a, 0xc4, 0x74, 0x58, 0xdb, 0x17, 0x9e, 0xeb,
0x15, 0x52, 0xe6, 0xb6, 0xea, 0xcc, 0x97, 0x5e, 0xe8, 0x95, 0x32, 0xdd, 0x24, 0x94, 0x61, 0xd3,
0xe9, 0xd9, 0x1e, 0x41, 0xbb, 0x47, 0xda, 0x81, 0xe5, 0xf9, 0x7e, 0xa9, 0xd9, 0xf2, 0xc0, 0xf9,
0x1a, 0x6a, 0xbf, 0x86, 0x4b, 0x68, 0xcb, 0x60, 0x55, 0x4a, 0x02, 0x10, 0x97, 0xfa, 0x75, 0x98,
0x8b, 0x2d, 0x8a, 0xeb, 0x91, 0x83, 0x24, 0x40, 0x58, 0xdb, 0x21, 0x9e, 0x54, 0xfd, 0x33, 0x64,
0xef, 0xb9, 0x04, 0x33, 0x52, 0x21, 0x94, 0xea, 0xb6, 0xa5, 0x91, 0xfd, 0x16, 0xa1, 0x0c, 0xe5,
0x61, 0xb2, 0x81, 0x19, 0xae, 0x61, 0x4a, 0x72, 0xca, 0xbc, 0xb2, 0x98, 0xd4, 0xc2, 0x39, 0xba,
0x0e, 0x13, 0xd4, 0xd3, 0xce, 0xc5, 0xe6, 0x95, 0xc5, 0xd4, 0x72, 0xbe, 0xd8, 0xc7, 0x7c, 0x31,
0x38, 0x2f, 0x50, 0x55, 0xdf, 0xc5, 0x60, 0xc2, 0x5f, 0x44, 0x08, 0xc6, 0x2c, 0x6c, 0x06, 0x27,
0x8b, 0x31, 0xfa, 0x3d, 0x24, 0x0c, 0x5c, 0x23, 0x06, 0xcd, 0xc5, 0xe6, 0xe3, 0x8b, 0xa9, 0xe5,
0xab, 0x47, 0x1f, 0x5a, 0xdc, 0x14, 0x8a, 0xeb, 0x16, 0x73, 0xdb, 0x9a, 0xbf, 0x0b, 0xdd, 0x84,
0x54, 0x5d, 0x7c, 0x49, 0x95, 0xbb, 0x22, 0x17, 0xef, 0x46, 0x16, 0xf8, 0xa9, 0xb8, 0x13, 0xf8,
0x49, 0x03, 0x4f, 0x9d, 0x2f, 0xa0, 0x5d, 0x38, 0x83, 0x1d, 0xc7, 0xb5, 0x0f, 0x75, 0x93, 0x9f,
0x60, 0x60, 0xca, 0xaa, 0x2d, 0xea, 0x1f, 0x35, 0x76, 0xec, 0x51, 0x73, 0x91, 0xcd, 0x9b, 0x98,
0xb2, 0x5d, 0x2a, 0x8e, 0xcd, 0xdf, 0x80, 0x54, 0x04, 0x2a, 0xca, 0x40, 0x7c, 0x8f, 0xb4, 0xfd,
0xaf, 0xe6, 0x43, 0x94, 0x85, 0xf1, 0x03, 0x6c, 0xb4, 0x88, 0x20, 0x32, 0xa9, 0x79, 0x93, 0xd5,
0xd8, 0x8a, 0xa2, 0x2e, 0xc0, 0xec, 0x43, 0xc2, 0x7a, 0xbc, 0x22, 0xe1, 0x4d, 0xfd, 0x87, 0x02,
0x27, 0x37, 0x75, 0x1a, 0xa8, 0xd2, 0x61, 0x3c, 0x78, 0x16, 0x92, 0x0e, 0x6e, 0x92, 0x2a, 0xd5,
0x5f, 0x7b, 0xa6, 0xc7, 0xb5, 0x49, 0xbe, 0x50, 0xd1, 0x5f, 0x13, 0xf4, 0x2b, 0x00, 0x21, 0x64,
0xf6, 0x1e, 0xb1, 0x04, 0x8f, 0x49, 0x4d, 0xa8, 0xef, 0xf0, 0x05, 0x34, 0x07, 0x89, 0x57, 0xba,
0xc1, 0x88, 0x2b, 0x78, 0x49, 0x6a, 0xfe, 0x4c, 0x3d, 0x80, 0x6c, 0x37, 0x0c, 0xea, 0xd8, 0x16,
0x25, 0xe8, 0xb7, 0x30, 0xe9, 0x87, 0x00, 0xcd, 0x29, 0xc2, 0xb3, 0x83, 0xc2, 0x25, 0xd4, 0x45,
0x57, 0x61, 0xc6, 0x22, 0x87, 0xac, 0x1a, 0xc1, 0xe2, 0x91, 0x94, 0xe6, 0xcb, 0xe5, 0x00, 0x8f,
0x5a, 0x80, 0xec, 0x7d, 0x62, 0x90, 0xbe, 0x08, 0x96, 0x71, 0xf5, 0x7e, 0x0c, 0x66, 0xd7, 0x0f,
0x49, 0xbd, 0xc5, 0x48, 0x65, 0xdf, 0x08, 0x34, 0x73, 0x9d, 0x78, 0xf6, 0x94, 0x83, 0x29, 0x7a,
0x04, 0xa9, 0xc8, 0x85, 0xf2, 0xa3, 0x5d, 0x16, 0x98, 0x3b, 0x1d, 0xad, 0x0a, 0x31, 0x48, 0x9d,
0xd9, 0xae, 0x16, 0xdd, 0xca, 0x5d, 0x4f, 0xf7, 0x0d, 0x9f, 0x4d, 0x3e, 0x44, 0x25, 0x48, 0x38,
0xd8, 0xc5, 0x26, 0xf5, 0xe3, 0xeb, 0x74, 0x5f, 0x7c, 0x55, 0xc4, 0x83, 0xa3, 0xf9, 0x6a, 0x68,
0x17, 0x52, 0x62, 0x54, 0xe5, 0xd7, 0x97, 0xe6, 0xc6, 0x05, 0x97, 0xd7, 0x25, 0x60, 0xfa, 0xbe,
0xb0, 0x58, 0xe6, 0xfb, 0x76, 0xf8, 0x36, 0xef, 0xce, 0x80, 0x13, 0x2e, 0xa0, 0x8b, 0x30, 0xc5,
0x1f, 0x16, 0x33, 0x20, 0x39, 0x31, 0xaf, 0x2c, 0x4e, 0x69, 0x29, 0x6f, 0xcd, 0x73, 0xf9, 0x16,
0xc0, 0x7e, 0x8b, 0xb8, 0xed, 0xaa, 0x69, 0x37, 0x48, 0x6e, 0x62, 0x5e, 0x59, 0x9c, 0x5e, 0x2e,
0x0e, 0x65, 0xf8, 0x29, 0xdf, 0xb6, 0x65, 0x37, 0x88, 0x96, 0xdc, 0x0f, 0x86, 0x68, 0x01, 0x66,
0x1c, 0xec, 0x32, 0x9d, 0x13, 0xe3, 0x1b, 0x9d, 0x14, 0x46, 0xa7, 0xc3, 0x65, 0x61, 0x37, 0xff,
0x0c, 0x66, 0x7a, 0x90, 0x4b, 0xae, 0xd0, 0xaf, 0xa3, 0x57, 0x28, 0x42, 0x63, 0xd4, 0x3b, 0x6d,
0x87, 0x44, 0xef, 0x56, 0x11, 0x92, 0x21, 0x30, 0x04, 0x90, 0x78, 0xb2, 0xad, 0x6d, 0xdd, 0xdd,
0xcc, 0x9c, 0x40, 0x93, 0x30, 0x56, 0xde, 0xbc, 0xfb, 0x24, 0xa3, 0xa0, 0x14, 0x4c, 0x94, 0xb5,
0xed, 0x07, 0x1b, 0x9b, 0xeb, 0x99, 0x98, 0xba, 0x07, 0x99, 0x72, 0x80, 0x6c, 0xdb, 0x11, 0x19,
0x04, 0x5d, 0x83, 0x6c, 0xe7, 0x23, 0xf8, 0x3d, 0xaa, 0xd6, 0xda, 0x8c, 0x50, 0x81, 0x2c, 0xae,
0xa1, 0x50, 0xc6, 0xaf, 0xd4, 0x1a, 0x97, 0xa0, 0x2b, 0x30, 0x6d, 0xe2, 0xc3, 0x6a, 0x28, 0xa1,
0x02, 0x71, 0x5c, 0x4b, 0x9b, 0xf8, 0x30, 0x3c, 0x9e, 0xaa, 0x5f, 0xc6, 0xe1, 0x54, 0x38, 0x15,
0x30, 0x7f, 0x66, 0x71, 0xfa, 0x47, 0x59, 0x9c, 0xae, 0x48, 0xc0, 0x48, 0xbf, 0x72, 0x60, 0xac,
0x96, 0x61, 0xb6, 0x43, 0xba, 0xed, 0x79, 0x42, 0x04, 0x6c, 0x6a, 0xf9, 0xd2, 0x20, 0x03, 0xbe,
0xd3, 0xb4, 0x8c, 0xd3, 0xb3, 0xf2, 0xa3, 0x85, 0xd8, 0x57, 0x31, 0xc8, 0x86, 0xe6, 0x35, 0x82,
0x1b, 0x3f, 0xa5, 0x13, 0xb3, 0x30, 0xce, 0x70, 0xcd, 0x20, 0xbe, 0x1b, 0xbd, 0x09, 0x5f, 0xd5,
0xad, 0x06, 0x39, 0xf4, 0xdf, 0x6d, 0x6f, 0xc2, 0xf1, 0xd4, 0x6d, 0xa3, 0x65, 0x5a, 0x9e, 0xa7,
0x92, 0x5a, 0x30, 0x45, 0xcb, 0x30, 0xb1, 0x47, 0xda, 0xbc, 0xdc, 0xf0, 0x29, 0x3e, 0x23, 0xc1,
0xf2, 0x98, 0xb4, 0x2b, 0x84, 0x69, 0x89, 0x3d, 0xf1, 0x2b, 0x77, 0x50, 0x72, 0x04, 0x07, 0xa9,
0xd7, 0x21, 0x19, 0x6a, 0xc9, 0x5e, 0x0e, 0x45, 0xf6, 0x72, 0xa8, 0x6f, 0x15, 0x98, 0x8d, 0xd0,
0xef, 0xa7, 0xa2, 0x5b, 0x3c, 0xb3, 0x85, 0xb7, 0xcf, 0x4b, 0x46, 0xe7, 0x06, 0xc1, 0xd2, 0x22,
0xfa, 0xe8, 0x8e, 0xcc, 0x3f, 0xe7, 0x07, 0xfb, 0xa7, 0xcb, 0x2f, 0xea, 0x37, 0x31, 0x48, 0xfd,
0x72, 0x62, 0x21, 0x0b, 0xe3, 0x86, 0x6e, 0xea, 0x4c, 0x3c, 0xee, 0x71, 0xcd, 0x9b, 0xf4, 0xa5,
0x9b, 0x64, 0x7f, 0xba, 0x91, 0x78, 0x19, 0xa4, 0x5e, 0x66, 0x70, 0x7a, 0x8d, 0x34, 0x75, 0x2b,
0x4a, 0xf8, 0xb1, 0xd4, 0xde, 0x86, 0x89, 0x20, 0x30, 0x3d, 0x5a, 0xaf, 0x0c, 0xa6, 0x35, 0x08,
0xcd, 0x60, 0x97, 0xfa, 0xbd, 0x02, 0xe9, 0x7b, 0xb6, 0x69, 0xea, 0xec, 0x78, 0x63, 0x0b, 0x30,
0x1d, 0x71, 0x46, 0x55, 0x6f, 0x08, 0x9b, 0x53, 0x8f, 0x4e, 0x68, 0xe9, 0xc8, 0xfa, 0x46, 0x03,
0xfd, 0x09, 0xe6, 0xa8, 0x6e, 0x35, 0x0d, 0xe2, 0x95, 0x9d, 0x11, 0xdf, 0xc7, 0x3f, 0x02, 0xe4,
0xa3, 0x13, 0x5a, 0xd6, 0x3b, 0x86, 0x57, 0xa0, 0x91, 0x28, 0xb8, 0x01, 0xc9, 0xa0, 0xbf, 0xe0,
0xef, 0x38, 0x0f, 0xfc, 0xb3, 0x92, 0x13, 0xb7, 0x7c, 0x1d, 0xad, 0xa3, 0xbd, 0x96, 0xee, 0x0a,
0x45, 0xf5, 0x39, 0x4c, 0x07, 0x1f, 0xef, 0xdf, 0xaa, 0x75, 0xc8, 0xd4, 0xc5, 0x4a, 0x35, 0xec,
0x81, 0x04, 0x0d, 0x83, 0x4b, 0xe6, 0x19, 0x6f, 0x4f, 0xb8, 0xa0, 0x6a, 0x30, 0xa3, 0xd9, 0x86,
0x51, 0xc3, 0xf5, 0xbd, 0xe3, 0x79, 0xbd, 0x22, 0xe7, 0xb5, 0x87, 0xd5, 0xe5, 0xbf, 0xcf, 0xc2,
0x44, 0xc5, 0xfb, 0x3c, 0xf4, 0x3f, 0xee, 0xb6, 0x68, 0xab, 0x83, 0x16, 0x24, 0x0c, 0xc8, 0x9a,
0xa1, 0xfc, 0x80, 0x82, 0x55, 0x5d, 0xff, 0xdb, 0xb7, 0xdf, 0xbd, 0x8d, 0xdd, 0x56, 0x57, 0x79,
0x63, 0xf5, 0xd7, 0xa0, 0xc2, 0xfe, 0x9d, 0xe3, 0xda, 0x7f, 0x21, 0x75, 0x46, 0x4b, 0x85, 0x92,
0x6e, 0x51, 0x86, 0xad, 0x3a, 0xe1, 0xe3, 0x40, 0x4e, 0x4b, 0x85, 0x37, 0xa5, 0xa0, 0xd4, 0x5d,
0x55, 0x0a, 0xe8, 0x9f, 0x0a, 0x40, 0xa7, 0xde, 0x47, 0x97, 0x25, 0x16, 0xfb, 0xda, 0x81, 0x81,
0xb8, 0xee, 0x08, 0x5c, 0xab, 0x68, 0x45, 0xe0, 0xe2, 0xd5, 0xef, 0x10, 0x98, 0x42, 0x48, 0xa5,
0xc2, 0x1b, 0xf4, 0x99, 0x02, 0x53, 0xd1, 0x8a, 0x1e, 0xc9, 0xde, 0x1f, 0x49, 0xe7, 0x91, 0x5f,
0x38, 0x56, 0xcf, 0x8b, 0x1c, 0x75, 0x4d, 0x60, 0xbc, 0x85, 0x46, 0xe0, 0x0e, 0xfd, 0x5b, 0x81,
0x74, 0x57, 0xfd, 0x2f, 0x75, 0xab, 0xac, 0x43, 0xc8, 0xcf, 0xf5, 0x85, 0xe7, 0x3a, 0xef, 0xff,
0x03, 0xea, 0x0a, 0x23, 0x51, 0x07, 0x9d, 0x62, 0x58, 0xea, 0xcd, 0xbe, 0x5a, 0x39, 0x2f, 0xcb,
0x44, 0x9a, 0x68, 0xf9, 0x2b, 0x84, 0xa9, 0x4f, 0x05, 0xa8, 0xc7, 0xea, 0x03, 0x01, 0xca, 0x37,
0xf6, 0x91, 0xb8, 0x56, 0x49, 0x68, 0x94, 0xc7, 0xdc, 0x17, 0x0a, 0x9c, 0x0c, 0x60, 0x30, 0x97,
0x60, 0x53, 0xb7, 0x9a, 0xc3, 0xc3, 0x3d, 0x32, 0x9f, 0x63, 0xa3, 0x83, 0xfa, 0x85, 0x40, 0xbd,
0xa3, 0x6e, 0x7f, 0x0a, 0xd4, 0x11, 0x8c, 0xab, 0x4a, 0xe1, 0x9a, 0x82, 0xfe, 0xa5, 0xc0, 0x18,
0xcf, 0xa7, 0xe8, 0xbc, 0x94, 0xba, 0x30, 0xd1, 0x1e, 0x43, 0xed, 0x63, 0x01, 0x72, 0x5d, 0xbd,
0x33, 0x0a, 0x48, 0x97, 0xe0, 0x06, 0x27, 0xf5, 0x9d, 0x02, 0xe9, 0x10, 0xe9, 0x50, 0xe0, 0x86,
0x22, 0x72, 0x47, 0x60, 0x7c, 0xa2, 0x6e, 0x8c, 0x82, 0x91, 0x46, 0x71, 0x79, 0x14, 0x7e, 0x50,
0x20, 0xd3, 0x9b, 0x43, 0x51, 0x41, 0x82, 0xe8, 0x88, 0x44, 0x9b, 0x3f, 0xa6, 0x00, 0x52, 0x9f,
0x0b, 0xe0, 0x4f, 0xd5, 0xcd, 0x51, 0x80, 0xd7, 0x7a, 0x8c, 0x73, 0xa2, 0xff, 0xaf, 0x40, 0xc2,
0xcb, 0x44, 0x68, 0x5e, 0xf6, 0x90, 0x47, 0x33, 0x74, 0xfe, 0xe2, 0x00, 0x0d, 0xff, 0x31, 0xda,
0x12, 0x40, 0x1f, 0xaa, 0x6b, 0xa3, 0x00, 0xf5, 0x92, 0x1a, 0x87, 0xf7, 0x5f, 0x05, 0x26, 0x83,
0x7c, 0x86, 0x54, 0x59, 0x08, 0x74, 0x27, 0xbb, 0x23, 0x5f, 0xa3, 0x6d, 0x81, 0x6b, 0x43, 0xbd,
0x3f, 0x52, 0x74, 0xfa, 0xc6, 0x38, 0xb2, 0x0f, 0x0a, 0x4c, 0x77, 0xb7, 0x5e, 0x68, 0x71, 0xd8,
0xee, 0x2c, 0x7f, 0x79, 0x60, 0xb9, 0x1c, 0x70, 0xb9, 0x2b, 0x30, 0x6f, 0xab, 0x7f, 0x18, 0x05,
0xb3, 0xd3, 0x05, 0x80, 0x23, 0x7f, 0xaf, 0x40, 0xba, 0xab, 0xa9, 0x92, 0xbe, 0xf5, 0xb2, 0xb6,
0x6b, 0x48, 0xdc, 0x9f, 0xe4, 0x96, 0x39, 0x51, 0xfb, 0xab, 0x4a, 0x61, 0xed, 0x3f, 0x0a, 0x9c,
0xaa, 0xdb, 0x66, 0x3f, 0x82, 0xb5, 0x29, 0xbf, 0x38, 0x29, 0x73, 0x97, 0x97, 0x95, 0x17, 0x2b,
0xbe, 0x4a, 0xd3, 0x36, 0xb0, 0xd5, 0x2c, 0xda, 0x6e, 0xb3, 0xd4, 0x24, 0x96, 0x08, 0x88, 0x92,
0x27, 0xc2, 0x8e, 0x4e, 0x23, 0x7f, 0xe5, 0xde, 0xf4, 0x87, 0x9f, 0xc7, 0x4e, 0x3f, 0xf4, 0xb6,
0xde, 0x33, 0xec, 0x56, 0xa3, 0xe8, 0x9f, 0x5b, 0x7c, 0xb6, 0xf4, 0x75, 0x20, 0x79, 0x29, 0x24,
0x2f, 0x7d, 0xc9, 0xcb, 0x67, 0x4b, 0xb5, 0x84, 0x38, 0xf8, 0x37, 0x3f, 0x04, 0x00, 0x00, 0xff,
0xff, 0x92, 0x18, 0x4b, 0x1c, 0x59, 0x17, 0x00, 0x00,
}