vendor/google.golang.org/genproto/googleapis/bigtable/admin/cluster/v1/bigtable_cluster_service.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto
   3
   4 package cluster
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10 import google_longrunning "google.golang.org/genproto/googleapis/longrunning"
  11 import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
  12
  13 import (
  14         context "golang.org/x/net/context"
  15         grpc "google.golang.org/grpc"
  16 )
  17
  18 // Reference imports to suppress errors if they are not otherwise used.
  19 var _ = proto.Marshal
  20 var _ = fmt.Errorf
  21 var _ = math.Inf
  22
  23 // Reference imports to suppress errors if they are not otherwise used.
  24 var _ context.Context
  25 var _ grpc.ClientConn
  26
  27 // This is a compile-time assertion to ensure that this generated file
  28 // is compatible with the grpc package it is being compiled against.
  29 const _ = grpc.SupportPackageIsVersion4
  30
  31 // Client API for BigtableClusterService service
  32
  33 type BigtableClusterServiceClient interface {
  34         // Lists the supported zones for the given project.
  35         ListZones(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error)
  36         // Gets information about a particular cluster.
  37         GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
  38         // Lists all clusters in the given project, along with any zones for which
  39         // cluster information could not be retrieved.
  40         ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error)
  41         // Creates a cluster and begins preparing it to begin serving. The returned
  42         // cluster embeds as its "current_operation" a long-running operation which
  43         // can be used to track the progress of turning up the new cluster.
  44         // Immediately upon completion of this request:
  45         //  * The cluster will be readable via the API, with all requested attributes
  46         //    but no allocated resources.
  47         // Until completion of the embedded operation:
  48         //  * Cancelling the operation will render the cluster immediately unreadable
  49         //    via the API.
  50         //  * All other attempts to modify or delete the cluster will be rejected.
  51         // Upon completion of the embedded operation:
  52         //  * Billing for all successfully-allocated resources will begin (some types
  53         //    may have lower than the requested levels).
  54         //  * New tables can be created in the cluster.
  55         //  * The cluster's allocated resource levels will be readable via the API.
  56         // The embedded operation's "metadata" field type is
  57         // [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
  58         // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
  59         CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Cluster, error)
  60         // Updates a cluster, and begins allocating or releasing resources as
  61         // requested. The returned cluster embeds as its "current_operation" a
  62         // long-running operation which can be used to track the progress of updating
  63         // the cluster.
  64         // Immediately upon completion of this request:
  65         //  * For resource types where a decrease in the cluster's allocation has been
  66         //    requested, billing will be based on the newly-requested level.
  67         // Until completion of the embedded operation:
  68         //  * Cancelling the operation will set its metadata's "cancelled_at_time",
  69         //    and begin restoring resources to their pre-request values. The operation
  70         //    is guaranteed to succeed at undoing all resource changes, after which
  71         //    point it will terminate with a CANCELLED status.
  72         //  * All other attempts to modify or delete the cluster will be rejected.
  73         //  * Reading the cluster via the API will continue to give the pre-request
  74         //    resource levels.
  75         // Upon completion of the embedded operation:
  76         //  * Billing will begin for all successfully-allocated resources (some types
  77         //    may have lower than the requested levels).
  78         //  * All newly-reserved resources will be available for serving the cluster's
  79         //    tables.
  80         //  * The cluster's new resource levels will be readable via the API.
  81         // [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
  82         // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
  83         UpdateCluster(ctx context.Context, in *Cluster, opts ...grpc.CallOption) (*Cluster, error)
  84         // Marks a cluster and all of its tables for permanent deletion in 7 days.
  85         // Immediately upon completion of the request:
  86         //  * Billing will cease for all of the cluster's reserved resources.
  87         //  * The cluster's "delete_time" field will be set 7 days in the future.
  88         // Soon afterward:
  89         //  * All tables within the cluster will become unavailable.
  90         // Prior to the cluster's "delete_time":
  91         //  * The cluster can be recovered with a call to UndeleteCluster.
  92         //  * All other attempts to modify or delete the cluster will be rejected.
  93         // At the cluster's "delete_time":
  94         //  * The cluster and *all of its tables* will immediately and irrevocably
  95         //    disappear from the API, and their data will be permanently deleted.
  96         DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
  97         // Cancels the scheduled deletion of an cluster and begins preparing it to
  98         // resume serving. The returned operation will also be embedded as the
  99         // cluster's "current_operation".
 100         // Immediately upon completion of this request:
 101         //  * The cluster's "delete_time" field will be unset, protecting it from
 102         //    automatic deletion.
 103         // Until completion of the returned operation:
 104         //  * The operation cannot be cancelled.
 105         // Upon completion of the returned operation:
 106         //  * Billing for the cluster's resources will resume.
 107         //  * All tables within the cluster will be available.
 108         // [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata] The embedded operation's "response" field type is
 109         // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
 110         UndeleteCluster(ctx context.Context, in *UndeleteClusterRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error)
 111 }
 112
 113 type bigtableClusterServiceClient struct {
 114         cc *grpc.ClientConn
 115 }
 116
 117 func NewBigtableClusterServiceClient(cc *grpc.ClientConn) BigtableClusterServiceClient {
 118         return &bigtableClusterServiceClient{cc}
 119 }
 120
 121 func (c *bigtableClusterServiceClient) ListZones(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error) {
 122         out := new(ListZonesResponse)
 123         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones", in, out, c.cc, opts...)
 124         if err != nil {
 125                 return nil, err
 126         }
 127         return out, nil
 128 }
 129
 130 func (c *bigtableClusterServiceClient) GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
 131         out := new(Cluster)
 132         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster", in, out, c.cc, opts...)
 133         if err != nil {
 134                 return nil, err
 135         }
 136         return out, nil
 137 }
 138
 139 func (c *bigtableClusterServiceClient) ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error) {
 140         out := new(ListClustersResponse)
 141         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters", in, out, c.cc, opts...)
 142         if err != nil {
 143                 return nil, err
 144         }
 145         return out, nil
 146 }
 147
 148 func (c *bigtableClusterServiceClient) CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Cluster, error) {
 149         out := new(Cluster)
 150         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster", in, out, c.cc, opts...)
 151         if err != nil {
 152                 return nil, err
 153         }
 154         return out, nil
 155 }
 156
 157 func (c *bigtableClusterServiceClient) UpdateCluster(ctx context.Context, in *Cluster, opts ...grpc.CallOption) (*Cluster, error) {
 158         out := new(Cluster)
 159         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster", in, out, c.cc, opts...)
 160         if err != nil {
 161                 return nil, err
 162         }
 163         return out, nil
 164 }
 165
 166 func (c *bigtableClusterServiceClient) DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
 167         out := new(google_protobuf2.Empty)
 168         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster", in, out, c.cc, opts...)
 169         if err != nil {
 170                 return nil, err
 171         }
 172         return out, nil
 173 }
 174
 175 func (c *bigtableClusterServiceClient) UndeleteCluster(ctx context.Context, in *UndeleteClusterRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) {
 176         out := new(google_longrunning.Operation)
 177         err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/UndeleteCluster", in, out, c.cc, opts...)
 178         if err != nil {
 179                 return nil, err
 180         }
 181         return out, nil
 182 }
 183
 184 // Server API for BigtableClusterService service
 185
 186 type BigtableClusterServiceServer interface {
 187         // Lists the supported zones for the given project.
 188         ListZones(context.Context, *ListZonesRequest) (*ListZonesResponse, error)
 189         // Gets information about a particular cluster.
 190         GetCluster(context.Context, *GetClusterRequest) (*Cluster, error)
 191         // Lists all clusters in the given project, along with any zones for which
 192         // cluster information could not be retrieved.
 193         ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error)
 194         // Creates a cluster and begins preparing it to begin serving. The returned
 195         // cluster embeds as its "current_operation" a long-running operation which
 196         // can be used to track the progress of turning up the new cluster.
 197         // Immediately upon completion of this request:
 198         //  * The cluster will be readable via the API, with all requested attributes
 199         //    but no allocated resources.
 200         // Until completion of the embedded operation:
 201         //  * Cancelling the operation will render the cluster immediately unreadable
 202         //    via the API.
 203         //  * All other attempts to modify or delete the cluster will be rejected.
 204         // Upon completion of the embedded operation:
 205         //  * Billing for all successfully-allocated resources will begin (some types
 206         //    may have lower than the requested levels).
 207         //  * New tables can be created in the cluster.
 208         //  * The cluster's allocated resource levels will be readable via the API.
 209         // The embedded operation's "metadata" field type is
 210         // [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
 211         // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
 212         CreateCluster(context.Context, *CreateClusterRequest) (*Cluster, error)
 213         // Updates a cluster, and begins allocating or releasing resources as
 214         // requested. The returned cluster embeds as its "current_operation" a
 215         // long-running operation which can be used to track the progress of updating
 216         // the cluster.
 217         // Immediately upon completion of this request:
 218         //  * For resource types where a decrease in the cluster's allocation has been
 219         //    requested, billing will be based on the newly-requested level.
 220         // Until completion of the embedded operation:
 221         //  * Cancelling the operation will set its metadata's "cancelled_at_time",
 222         //    and begin restoring resources to their pre-request values. The operation
 223         //    is guaranteed to succeed at undoing all resource changes, after which
 224         //    point it will terminate with a CANCELLED status.
 225         //  * All other attempts to modify or delete the cluster will be rejected.
 226         //  * Reading the cluster via the API will continue to give the pre-request
 227         //    resource levels.
 228         // Upon completion of the embedded operation:
 229         //  * Billing will begin for all successfully-allocated resources (some types
 230         //    may have lower than the requested levels).
 231         //  * All newly-reserved resources will be available for serving the cluster's
 232         //    tables.
 233         //  * The cluster's new resource levels will be readable via the API.
 234         // [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
 235         // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
 236         UpdateCluster(context.Context, *Cluster) (*Cluster, error)
 237         // Marks a cluster and all of its tables for permanent deletion in 7 days.
 238         // Immediately upon completion of the request:
 239         //  * Billing will cease for all of the cluster's reserved resources.
 240         //  * The cluster's "delete_time" field will be set 7 days in the future.
 241         // Soon afterward:
 242         //  * All tables within the cluster will become unavailable.
 243         // Prior to the cluster's "delete_time":
 244         //  * The cluster can be recovered with a call to UndeleteCluster.
 245         //  * All other attempts to modify or delete the cluster will be rejected.
 246         // At the cluster's "delete_time":
 247         //  * The cluster and *all of its tables* will immediately and irrevocably
 248         //    disappear from the API, and their data will be permanently deleted.
 249         DeleteCluster(context.Context, *DeleteClusterRequest) (*google_protobuf2.Empty, error)
 250         // Cancels the scheduled deletion of an cluster and begins preparing it to
 251         // resume serving. The returned operation will also be embedded as the
 252         // cluster's "current_operation".
 253         // Immediately upon completion of this request:
 254         //  * The cluster's "delete_time" field will be unset, protecting it from
 255         //    automatic deletion.
 256         // Until completion of the returned operation:
 257         //  * The operation cannot be cancelled.
 258         // Upon completion of the returned operation:
 259         //  * Billing for the cluster's resources will resume.
 260         //  * All tables within the cluster will be available.
 261         // [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata] The embedded operation's "response" field type is
 262         // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
 263         UndeleteCluster(context.Context, *UndeleteClusterRequest) (*google_longrunning.Operation, error)
 264 }
 265
 266 func RegisterBigtableClusterServiceServer(s *grpc.Server, srv BigtableClusterServiceServer) {
 267         s.RegisterService(&_BigtableClusterService_serviceDesc, srv)
 268 }
 269
 270 func _BigtableClusterService_ListZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 271         in := new(ListZonesRequest)
 272         if err := dec(in); err != nil {
 273                 return nil, err
 274         }
 275         if interceptor == nil {
 276                 return srv.(BigtableClusterServiceServer).ListZones(ctx, in)
 277         }
 278         info := &grpc.UnaryServerInfo{
 279                 Server:     srv,
 280                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones",
 281         }
 282         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 283                 return srv.(BigtableClusterServiceServer).ListZones(ctx, req.(*ListZonesRequest))
 284         }
 285         return interceptor(ctx, in, info, handler)
 286 }
 287
 288 func _BigtableClusterService_GetCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 289         in := new(GetClusterRequest)
 290         if err := dec(in); err != nil {
 291                 return nil, err
 292         }
 293         if interceptor == nil {
 294                 return srv.(BigtableClusterServiceServer).GetCluster(ctx, in)
 295         }
 296         info := &grpc.UnaryServerInfo{
 297                 Server:     srv,
 298                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster",
 299         }
 300         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 301                 return srv.(BigtableClusterServiceServer).GetCluster(ctx, req.(*GetClusterRequest))
 302         }
 303         return interceptor(ctx, in, info, handler)
 304 }
 305
 306 func _BigtableClusterService_ListClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 307         in := new(ListClustersRequest)
 308         if err := dec(in); err != nil {
 309                 return nil, err
 310         }
 311         if interceptor == nil {
 312                 return srv.(BigtableClusterServiceServer).ListClusters(ctx, in)
 313         }
 314         info := &grpc.UnaryServerInfo{
 315                 Server:     srv,
 316                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters",
 317         }
 318         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 319                 return srv.(BigtableClusterServiceServer).ListClusters(ctx, req.(*ListClustersRequest))
 320         }
 321         return interceptor(ctx, in, info, handler)
 322 }
 323
 324 func _BigtableClusterService_CreateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 325         in := new(CreateClusterRequest)
 326         if err := dec(in); err != nil {
 327                 return nil, err
 328         }
 329         if interceptor == nil {
 330                 return srv.(BigtableClusterServiceServer).CreateCluster(ctx, in)
 331         }
 332         info := &grpc.UnaryServerInfo{
 333                 Server:     srv,
 334                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster",
 335         }
 336         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 337                 return srv.(BigtableClusterServiceServer).CreateCluster(ctx, req.(*CreateClusterRequest))
 338         }
 339         return interceptor(ctx, in, info, handler)
 340 }
 341
 342 func _BigtableClusterService_UpdateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 343         in := new(Cluster)
 344         if err := dec(in); err != nil {
 345                 return nil, err
 346         }
 347         if interceptor == nil {
 348                 return srv.(BigtableClusterServiceServer).UpdateCluster(ctx, in)
 349         }
 350         info := &grpc.UnaryServerInfo{
 351                 Server:     srv,
 352                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster",
 353         }
 354         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 355                 return srv.(BigtableClusterServiceServer).UpdateCluster(ctx, req.(*Cluster))
 356         }
 357         return interceptor(ctx, in, info, handler)
 358 }
 359
 360 func _BigtableClusterService_DeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 361         in := new(DeleteClusterRequest)
 362         if err := dec(in); err != nil {
 363                 return nil, err
 364         }
 365         if interceptor == nil {
 366                 return srv.(BigtableClusterServiceServer).DeleteCluster(ctx, in)
 367         }
 368         info := &grpc.UnaryServerInfo{
 369                 Server:     srv,
 370                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster",
 371         }
 372         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 373                 return srv.(BigtableClusterServiceServer).DeleteCluster(ctx, req.(*DeleteClusterRequest))
 374         }
 375         return interceptor(ctx, in, info, handler)
 376 }
 377
 378 func _BigtableClusterService_UndeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 379         in := new(UndeleteClusterRequest)
 380         if err := dec(in); err != nil {
 381                 return nil, err
 382         }
 383         if interceptor == nil {
 384                 return srv.(BigtableClusterServiceServer).UndeleteCluster(ctx, in)
 385         }
 386         info := &grpc.UnaryServerInfo{
 387                 Server:     srv,
 388                 FullMethod: "/google.bigtable.admin.cluster.v1.BigtableClusterService/UndeleteCluster",
 389         }
 390         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 391                 return srv.(BigtableClusterServiceServer).UndeleteCluster(ctx, req.(*UndeleteClusterRequest))
 392         }
 393         return interceptor(ctx, in, info, handler)
 394 }
 395
 396 var _BigtableClusterService_serviceDesc = grpc.ServiceDesc{
 397         ServiceName: "google.bigtable.admin.cluster.v1.BigtableClusterService",
 398         HandlerType: (*BigtableClusterServiceServer)(nil),
 399         Methods: []grpc.MethodDesc{
 400                 {
 401                         MethodName: "ListZones",
 402                         Handler:    _BigtableClusterService_ListZones_Handler,
 403                 },
 404                 {
 405                         MethodName: "GetCluster",
 406                         Handler:    _BigtableClusterService_GetCluster_Handler,
 407                 },
 408                 {
 409                         MethodName: "ListClusters",
 410                         Handler:    _BigtableClusterService_ListClusters_Handler,
 411                 },
 412                 {
 413                         MethodName: "CreateCluster",
 414                         Handler:    _BigtableClusterService_CreateCluster_Handler,
 415                 },
 416                 {
 417                         MethodName: "UpdateCluster",
 418                         Handler:    _BigtableClusterService_UpdateCluster_Handler,
 419                 },
 420                 {
 421                         MethodName: "DeleteCluster",
 422                         Handler:    _BigtableClusterService_DeleteCluster_Handler,
 423                 },
 424                 {
 425                         MethodName: "UndeleteCluster",
 426                         Handler:    _BigtableClusterService_UndeleteCluster_Handler,
 427                 },
 428         },
 429         Streams:  []grpc.StreamDesc{},
 430         Metadata: "google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto",
 431 }
 432
 433 func init() {
 434         proto.RegisterFile("google/bigtable/admin/cluster/v1/bigtable_cluster_service.proto", fileDescriptor1)
 435 }
 436
 437 var fileDescriptor1 = []byte{
 438         // 515 bytes of a gzipped FileDescriptorProto
 439         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0x4f, 0x6b, 0x14, 0x31,
 440         0x18, 0xc6, 0x89, 0x07, 0xa1, 0xc1, 0x45, 0xc8, 0xa1, 0x87, 0x6d, 0x0b, 0x32, 0x15, 0xb1, 0x23,
 441         0x26, 0x6e, 0x17, 0xc5, 0xbf, 0x08, 0x5b, 0xa5, 0x1e, 0x04, 0x8b, 0xd2, 0x4b, 0x2f, 0x4b, 0x76,
 442         0xe7, 0x35, 0x8c, 0xcc, 0x24, 0x31, 0xc9, 0x2c, 0xa8, 0xf4, 0xe2, 0xcd, 0x93, 0x88, 0x27, 0x3d,
 443         0x78, 0xeb, 0xdd, 0xef, 0xe2, 0x57, 0xf0, 0x83, 0xc8, 0x64, 0x92, 0xb5, 0x2b, 0x6b, 0x77, 0xa6,
 444         0xb7, 0x99, 0xc9, 0xfb, 0xbc, 0xcf, 0x6f, 0x9e, 0x24, 0x2f, 0x7e, 0x2c, 0x94, 0x12, 0x05, 0xb0,
 445         0x49, 0x2e, 0x1c, 0x9f, 0x14, 0xc0, 0x78, 0x56, 0xe6, 0x92, 0x4d, 0x8b, 0xca, 0x3a, 0x30, 0x6c,
 446         0x36, 0x98, 0xaf, 0x8c, 0xc3, 0xb7, 0xb1, 0x05, 0x33, 0xcb, 0xa7, 0x40, 0xb5, 0x51, 0x4e, 0x91,
 447         0x2b, 0x4d, 0x03, 0x1a, 0xcb, 0xa8, 0x6f, 0x40, 0x43, 0x31, 0x9d, 0x0d, 0xfa, 0x9b, 0xc1, 0x82,
 448         0xeb, 0x9c, 0x71, 0x29, 0x95, 0xe3, 0x2e, 0x57, 0xd2, 0x36, 0xfa, 0xfe, 0xc3, 0xee, 0x00, 0x19,
 449         0x77, 0x3c, 0xa8, 0x9f, 0x9d, 0x1b, 0x7f, 0x5c, 0x82, 0xb5, 0x5c, 0x40, 0xe4, 0xd8, 0x0e, 0x9d,
 450         0x0a, 0x25, 0x85, 0xa9, 0xa4, 0xcc, 0xa5, 0x60, 0x4a, 0x83, 0x59, 0x80, 0xdd, 0x08, 0x45, 0xfe,
 451         0x6d, 0x52, 0xbd, 0x66, 0x50, 0x6a, 0xf7, 0xae, 0x59, 0xdc, 0xfd, 0xb4, 0x86, 0xd7, 0x47, 0xc1,
 452         0x6d, 0xaf, 0x31, 0x7b, 0xd5, 0x78, 0x91, 0x6f, 0x08, 0xaf, 0x3d, 0xcf, 0xad, 0x3b, 0x52, 0x12,
 453         0x2c, 0xd9, 0xa5, 0xab, 0x32, 0xa3, 0xf3, 0xe2, 0x97, 0xf0, 0xb6, 0x02, 0xeb, 0xfa, 0xc3, 0x4e,
 454         0x1a, 0xab, 0x95, 0xb4, 0x90, 0x6c, 0x7f, 0xfc, 0xf5, 0xfb, 0xeb, 0x85, 0x2d, 0xb2, 0x51, 0x07,
 455         0xf1, 0x41, 0xf2, 0x12, 0x1e, 0x69, 0xa3, 0xde, 0xc0, 0xd4, 0x59, 0x96, 0x1e, 0xb3, 0xf7, 0x9e,
 456         0xe6, 0x07, 0xc2, 0x78, 0x1f, 0x5c, 0x20, 0x26, 0x2d, 0x8c, 0xfe, 0x56, 0x47, 0xba, 0x9d, 0xd5,
 457         0xa2, 0xa0, 0x48, 0x6e, 0x79, 0xa6, 0x94, 0x5c, 0x5f, 0xc6, 0xd4, 0x20, 0xb1, 0x34, 0x6e, 0x60,
 458         0x8d, 0x49, 0x7e, 0x22, 0x7c, 0xa9, 0xfe, 0xb7, 0xd0, 0xc1, 0x92, 0xdb, 0xed, 0xb2, 0x88, 0xf5,
 459         0x11, 0xf2, 0x4e, 0x57, 0x59, 0x48, 0x71, 0xe0, 0x89, 0x6f, 0x90, 0x9d, 0xe5, 0x29, 0x72, 0x21,
 460         0x0c, 0x08, 0xee, 0x20, 0x9b, 0x53, 0x93, 0x13, 0x84, 0x7b, 0x7b, 0x06, 0xb8, 0x8b, 0x07, 0x81,
 461         0xb4, 0x30, 0x5f, 0x10, 0x9c, 0x23, 0xd9, 0xc0, 0x99, 0x5c, 0x3b, 0x2b, 0xd9, 0xe3, 0x39, 0xe4,
 462         0x7d, 0x94, 0x92, 0xef, 0x08, 0xf7, 0x0e, 0x75, 0x76, 0x8a, 0xb3, 0xbd, 0x5f, 0x17, 0xb4, 0xa1,
 463         0x47, 0xbb, 0xd9, 0x6f, 0xbd, 0xe9, 0x35, 0xdc, 0x17, 0x84, 0x7b, 0x4f, 0xa0, 0x80, 0x4e, 0x21,
 464         0x2e, 0x08, 0x62, 0x88, 0xeb, 0x51, 0x17, 0xef, 0x2d, 0x7d, 0x5a, 0xdf, 0xdb, 0x78, 0x16, 0xd3,
 465         0xf6, 0x67, 0xf1, 0x04, 0xe1, 0xcb, 0x87, 0x32, 0x5b, 0xa0, 0xba, 0xbb, 0x9a, 0xea, 0x1f, 0x49,
 466         0xe4, 0xda, 0x8a, 0xca, 0x53, 0x43, 0x87, 0xbe, 0x88, 0x43, 0x27, 0xb9, 0xe7, 0xf1, 0x86, 0xc9,
 467         0xa0, 0x75, 0x6a, 0x55, 0xf0, 0x19, 0x7d, 0x46, 0xf8, 0xea, 0x54, 0x95, 0x2b, 0xc9, 0x46, 0x9b,
 468         0xcb, 0x27, 0x96, 0x3d, 0xa8, 0x93, 0x3a, 0x40, 0x47, 0xfb, 0xa1, 0x83, 0x50, 0x05, 0x97, 0x82,
 469         0x2a, 0x23, 0x98, 0x00, 0xe9, 0x73, 0x64, 0xcd, 0x12, 0xd7, 0xb9, 0xfd, 0xff, 0xfc, 0x7d, 0x10,
 470         0x1e, 0x27, 0x17, 0xbd, 0x66, 0xf8, 0x27, 0x00, 0x00, 0xff, 0xff, 0x50, 0x92, 0x91, 0x86, 0x71,
 471         0x06, 0x00, 0x00,
 472 }