vendor/google.golang.org/genproto/googleapis/longrunning/operations.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/longrunning/operations.proto
   3
   4 /*
   5 Package longrunning is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/longrunning/operations.proto
   9
  10 It has these top-level messages:
  11         Operation
  12         GetOperationRequest
  13         ListOperationsRequest
  14         ListOperationsResponse
  15         CancelOperationRequest
  16         DeleteOperationRequest
  17 */
  18 package longrunning
  19
  20 import proto "github.com/golang/protobuf/proto"
  21 import fmt "fmt"
  22 import math "math"
  23 import _ "google.golang.org/genproto/googleapis/api/annotations"
  24 import google_protobuf1 "github.com/golang/protobuf/ptypes/any"
  25 import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
  26 import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
  27
  28 import (
  29         context "golang.org/x/net/context"
  30         grpc "google.golang.org/grpc"
  31 )
  32
  33 // Reference imports to suppress errors if they are not otherwise used.
  34 var _ = proto.Marshal
  35 var _ = fmt.Errorf
  36 var _ = math.Inf
  37
  38 // This is a compile-time assertion to ensure that this generated file
  39 // is compatible with the proto package it is being compiled against.
  40 // A compilation error at this line likely means your copy of the
  41 // proto package needs to be updated.
  42 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  43
  44 // This resource represents a long-running operation that is the result of a
  45 // network API call.
  46 type Operation struct {
  47         // The server-assigned name, which is only unique within the same service that
  48         // originally returns it. If you use the default HTTP mapping, the
  49         // `name` should have the format of `operations/some/unique/name`.
  50         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
  51         // Service-specific metadata associated with the operation.  It typically
  52         // contains progress information and common metadata such as create time.
  53         // Some services might not provide such metadata.  Any method that returns a
  54         // long-running operation should document the metadata type, if any.
  55         Metadata *google_protobuf1.Any `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"`
  56         // If the value is `false`, it means the operation is still in progress.
  57         // If true, the operation is completed, and either `error` or `response` is
  58         // available.
  59         Done bool `protobuf:"varint,3,opt,name=done" json:"done,omitempty"`
  60         // The operation result, which can be either an `error` or a valid `response`.
  61         // If `done` == `false`, neither `error` nor `response` is set.
  62         // If `done` == `true`, exactly one of `error` or `response` is set.
  63         //
  64         // Types that are valid to be assigned to Result:
  65         //      *Operation_Error
  66         //      *Operation_Response
  67         Result isOperation_Result `protobuf_oneof:"result"`
  68 }
  69
  70 func (m *Operation) Reset()                    { *m = Operation{} }
  71 func (m *Operation) String() string            { return proto.CompactTextString(m) }
  72 func (*Operation) ProtoMessage()               {}
  73 func (*Operation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  74
  75 type isOperation_Result interface {
  76         isOperation_Result()
  77 }
  78
  79 type Operation_Error struct {
  80         Error *google_rpc.Status `protobuf:"bytes,4,opt,name=error,oneof"`
  81 }
  82 type Operation_Response struct {
  83         Response *google_protobuf1.Any `protobuf:"bytes,5,opt,name=response,oneof"`
  84 }
  85
  86 func (*Operation_Error) isOperation_Result()    {}
  87 func (*Operation_Response) isOperation_Result() {}
  88
  89 func (m *Operation) GetResult() isOperation_Result {
  90         if m != nil {
  91                 return m.Result
  92         }
  93         return nil
  94 }
  95
  96 func (m *Operation) GetName() string {
  97         if m != nil {
  98                 return m.Name
  99         }
 100         return ""
 101 }
 102
 103 func (m *Operation) GetMetadata() *google_protobuf1.Any {
 104         if m != nil {
 105                 return m.Metadata
 106         }
 107         return nil
 108 }
 109
 110 func (m *Operation) GetDone() bool {
 111         if m != nil {
 112                 return m.Done
 113         }
 114         return false
 115 }
 116
 117 func (m *Operation) GetError() *google_rpc.Status {
 118         if x, ok := m.GetResult().(*Operation_Error); ok {
 119                 return x.Error
 120         }
 121         return nil
 122 }
 123
 124 func (m *Operation) GetResponse() *google_protobuf1.Any {
 125         if x, ok := m.GetResult().(*Operation_Response); ok {
 126                 return x.Response
 127         }
 128         return nil
 129 }
 130
 131 // XXX_OneofFuncs is for the internal use of the proto package.
 132 func (*Operation) 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{}) {
 133         return _Operation_OneofMarshaler, _Operation_OneofUnmarshaler, _Operation_OneofSizer, []interface{}{
 134                 (*Operation_Error)(nil),
 135                 (*Operation_Response)(nil),
 136         }
 137 }
 138
 139 func _Operation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 140         m := msg.(*Operation)
 141         // result
 142         switch x := m.Result.(type) {
 143         case *Operation_Error:
 144                 b.EncodeVarint(4<<3 | proto.WireBytes)
 145                 if err := b.EncodeMessage(x.Error); err != nil {
 146                         return err
 147                 }
 148         case *Operation_Response:
 149                 b.EncodeVarint(5<<3 | proto.WireBytes)
 150                 if err := b.EncodeMessage(x.Response); err != nil {
 151                         return err
 152                 }
 153         case nil:
 154         default:
 155                 return fmt.Errorf("Operation.Result has unexpected type %T", x)
 156         }
 157         return nil
 158 }
 159
 160 func _Operation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 161         m := msg.(*Operation)
 162         switch tag {
 163         case 4: // result.error
 164                 if wire != proto.WireBytes {
 165                         return true, proto.ErrInternalBadWireType
 166                 }
 167                 msg := new(google_rpc.Status)
 168                 err := b.DecodeMessage(msg)
 169                 m.Result = &Operation_Error{msg}
 170                 return true, err
 171         case 5: // result.response
 172                 if wire != proto.WireBytes {
 173                         return true, proto.ErrInternalBadWireType
 174                 }
 175                 msg := new(google_protobuf1.Any)
 176                 err := b.DecodeMessage(msg)
 177                 m.Result = &Operation_Response{msg}
 178                 return true, err
 179         default:
 180                 return false, nil
 181         }
 182 }
 183
 184 func _Operation_OneofSizer(msg proto.Message) (n int) {
 185         m := msg.(*Operation)
 186         // result
 187         switch x := m.Result.(type) {
 188         case *Operation_Error:
 189                 s := proto.Size(x.Error)
 190                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 191                 n += proto.SizeVarint(uint64(s))
 192                 n += s
 193         case *Operation_Response:
 194                 s := proto.Size(x.Response)
 195                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 196                 n += proto.SizeVarint(uint64(s))
 197                 n += s
 198         case nil:
 199         default:
 200                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 201         }
 202         return n
 203 }
 204
 205 // The request message for [Operations.GetOperation][google.longrunning.Operations.GetOperation].
 206 type GetOperationRequest struct {
 207         // The name of the operation resource.
 208         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 209 }
 210
 211 func (m *GetOperationRequest) Reset()                    { *m = GetOperationRequest{} }
 212 func (m *GetOperationRequest) String() string            { return proto.CompactTextString(m) }
 213 func (*GetOperationRequest) ProtoMessage()               {}
 214 func (*GetOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 215
 216 func (m *GetOperationRequest) GetName() string {
 217         if m != nil {
 218                 return m.Name
 219         }
 220         return ""
 221 }
 222
 223 // The request message for [Operations.ListOperations][google.longrunning.Operations.ListOperations].
 224 type ListOperationsRequest struct {
 225         // The name of the operation collection.
 226         Name string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
 227         // The standard list filter.
 228         Filter string `protobuf:"bytes,1,opt,name=filter" json:"filter,omitempty"`
 229         // The standard list page size.
 230         PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize" json:"page_size,omitempty"`
 231         // The standard list page token.
 232         PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
 233 }
 234
 235 func (m *ListOperationsRequest) Reset()                    { *m = ListOperationsRequest{} }
 236 func (m *ListOperationsRequest) String() string            { return proto.CompactTextString(m) }
 237 func (*ListOperationsRequest) ProtoMessage()               {}
 238 func (*ListOperationsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 239
 240 func (m *ListOperationsRequest) GetName() string {
 241         if m != nil {
 242                 return m.Name
 243         }
 244         return ""
 245 }
 246
 247 func (m *ListOperationsRequest) GetFilter() string {
 248         if m != nil {
 249                 return m.Filter
 250         }
 251         return ""
 252 }
 253
 254 func (m *ListOperationsRequest) GetPageSize() int32 {
 255         if m != nil {
 256                 return m.PageSize
 257         }
 258         return 0
 259 }
 260
 261 func (m *ListOperationsRequest) GetPageToken() string {
 262         if m != nil {
 263                 return m.PageToken
 264         }
 265         return ""
 266 }
 267
 268 // The response message for [Operations.ListOperations][google.longrunning.Operations.ListOperations].
 269 type ListOperationsResponse struct {
 270         // A list of operations that matches the specified filter in the request.
 271         Operations []*Operation `protobuf:"bytes,1,rep,name=operations" json:"operations,omitempty"`
 272         // The standard List next-page token.
 273         NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken" json:"next_page_token,omitempty"`
 274 }
 275
 276 func (m *ListOperationsResponse) Reset()                    { *m = ListOperationsResponse{} }
 277 func (m *ListOperationsResponse) String() string            { return proto.CompactTextString(m) }
 278 func (*ListOperationsResponse) ProtoMessage()               {}
 279 func (*ListOperationsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 280
 281 func (m *ListOperationsResponse) GetOperations() []*Operation {
 282         if m != nil {
 283                 return m.Operations
 284         }
 285         return nil
 286 }
 287
 288 func (m *ListOperationsResponse) GetNextPageToken() string {
 289         if m != nil {
 290                 return m.NextPageToken
 291         }
 292         return ""
 293 }
 294
 295 // The request message for [Operations.CancelOperation][google.longrunning.Operations.CancelOperation].
 296 type CancelOperationRequest struct {
 297         // The name of the operation resource to be cancelled.
 298         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 299 }
 300
 301 func (m *CancelOperationRequest) Reset()                    { *m = CancelOperationRequest{} }
 302 func (m *CancelOperationRequest) String() string            { return proto.CompactTextString(m) }
 303 func (*CancelOperationRequest) ProtoMessage()               {}
 304 func (*CancelOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 305
 306 func (m *CancelOperationRequest) GetName() string {
 307         if m != nil {
 308                 return m.Name
 309         }
 310         return ""
 311 }
 312
 313 // The request message for [Operations.DeleteOperation][google.longrunning.Operations.DeleteOperation].
 314 type DeleteOperationRequest struct {
 315         // The name of the operation resource to be deleted.
 316         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 317 }
 318
 319 func (m *DeleteOperationRequest) Reset()                    { *m = DeleteOperationRequest{} }
 320 func (m *DeleteOperationRequest) String() string            { return proto.CompactTextString(m) }
 321 func (*DeleteOperationRequest) ProtoMessage()               {}
 322 func (*DeleteOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 323
 324 func (m *DeleteOperationRequest) GetName() string {
 325         if m != nil {
 326                 return m.Name
 327         }
 328         return ""
 329 }
 330
 331 func init() {
 332         proto.RegisterType((*Operation)(nil), "google.longrunning.Operation")
 333         proto.RegisterType((*GetOperationRequest)(nil), "google.longrunning.GetOperationRequest")
 334         proto.RegisterType((*ListOperationsRequest)(nil), "google.longrunning.ListOperationsRequest")
 335         proto.RegisterType((*ListOperationsResponse)(nil), "google.longrunning.ListOperationsResponse")
 336         proto.RegisterType((*CancelOperationRequest)(nil), "google.longrunning.CancelOperationRequest")
 337         proto.RegisterType((*DeleteOperationRequest)(nil), "google.longrunning.DeleteOperationRequest")
 338 }
 339
 340 // Reference imports to suppress errors if they are not otherwise used.
 341 var _ context.Context
 342 var _ grpc.ClientConn
 343
 344 // This is a compile-time assertion to ensure that this generated file
 345 // is compatible with the grpc package it is being compiled against.
 346 const _ = grpc.SupportPackageIsVersion4
 347
 348 // Client API for Operations service
 349
 350 type OperationsClient interface {
 351         // Lists operations that match the specified filter in the request. If the
 352         // server doesn't support this method, it returns `UNIMPLEMENTED`.
 353         //
 354         // NOTE: the `name` binding below allows API services to override the binding
 355         // to use different resource name schemes, such as `users/*/operations`.
 356         ListOperations(ctx context.Context, in *ListOperationsRequest, opts ...grpc.CallOption) (*ListOperationsResponse, error)
 357         // Gets the latest state of a long-running operation.  Clients can use this
 358         // method to poll the operation result at intervals as recommended by the API
 359         // service.
 360         GetOperation(ctx context.Context, in *GetOperationRequest, opts ...grpc.CallOption) (*Operation, error)
 361         // Deletes a long-running operation. This method indicates that the client is
 362         // no longer interested in the operation result. It does not cancel the
 363         // operation. If the server doesn't support this method, it returns
 364         // `google.rpc.Code.UNIMPLEMENTED`.
 365         DeleteOperation(ctx context.Context, in *DeleteOperationRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
 366         // Starts asynchronous cancellation on a long-running operation.  The server
 367         // makes a best effort to cancel the operation, but success is not
 368         // guaranteed.  If the server doesn't support this method, it returns
 369         // `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
 370         // [Operations.GetOperation][google.longrunning.Operations.GetOperation] or
 371         // other methods to check whether the cancellation succeeded or whether the
 372         // operation completed despite cancellation. On successful cancellation,
 373         // the operation is not deleted; instead, it becomes an operation with
 374         // an [Operation.error][google.longrunning.Operation.error] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1,
 375         // corresponding to `Code.CANCELLED`.
 376         CancelOperation(ctx context.Context, in *CancelOperationRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
 377 }
 378
 379 type operationsClient struct {
 380         cc *grpc.ClientConn
 381 }
 382
 383 func NewOperationsClient(cc *grpc.ClientConn) OperationsClient {
 384         return &operationsClient{cc}
 385 }
 386
 387 func (c *operationsClient) ListOperations(ctx context.Context, in *ListOperationsRequest, opts ...grpc.CallOption) (*ListOperationsResponse, error) {
 388         out := new(ListOperationsResponse)
 389         err := grpc.Invoke(ctx, "/google.longrunning.Operations/ListOperations", in, out, c.cc, opts...)
 390         if err != nil {
 391                 return nil, err
 392         }
 393         return out, nil
 394 }
 395
 396 func (c *operationsClient) GetOperation(ctx context.Context, in *GetOperationRequest, opts ...grpc.CallOption) (*Operation, error) {
 397         out := new(Operation)
 398         err := grpc.Invoke(ctx, "/google.longrunning.Operations/GetOperation", in, out, c.cc, opts...)
 399         if err != nil {
 400                 return nil, err
 401         }
 402         return out, nil
 403 }
 404
 405 func (c *operationsClient) DeleteOperation(ctx context.Context, in *DeleteOperationRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
 406         out := new(google_protobuf2.Empty)
 407         err := grpc.Invoke(ctx, "/google.longrunning.Operations/DeleteOperation", in, out, c.cc, opts...)
 408         if err != nil {
 409                 return nil, err
 410         }
 411         return out, nil
 412 }
 413
 414 func (c *operationsClient) CancelOperation(ctx context.Context, in *CancelOperationRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
 415         out := new(google_protobuf2.Empty)
 416         err := grpc.Invoke(ctx, "/google.longrunning.Operations/CancelOperation", in, out, c.cc, opts...)
 417         if err != nil {
 418                 return nil, err
 419         }
 420         return out, nil
 421 }
 422
 423 // Server API for Operations service
 424
 425 type OperationsServer interface {
 426         // Lists operations that match the specified filter in the request. If the
 427         // server doesn't support this method, it returns `UNIMPLEMENTED`.
 428         //
 429         // NOTE: the `name` binding below allows API services to override the binding
 430         // to use different resource name schemes, such as `users/*/operations`.
 431         ListOperations(context.Context, *ListOperationsRequest) (*ListOperationsResponse, error)
 432         // Gets the latest state of a long-running operation.  Clients can use this
 433         // method to poll the operation result at intervals as recommended by the API
 434         // service.
 435         GetOperation(context.Context, *GetOperationRequest) (*Operation, error)
 436         // Deletes a long-running operation. This method indicates that the client is
 437         // no longer interested in the operation result. It does not cancel the
 438         // operation. If the server doesn't support this method, it returns
 439         // `google.rpc.Code.UNIMPLEMENTED`.
 440         DeleteOperation(context.Context, *DeleteOperationRequest) (*google_protobuf2.Empty, error)
 441         // Starts asynchronous cancellation on a long-running operation.  The server
 442         // makes a best effort to cancel the operation, but success is not
 443         // guaranteed.  If the server doesn't support this method, it returns
 444         // `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
 445         // [Operations.GetOperation][google.longrunning.Operations.GetOperation] or
 446         // other methods to check whether the cancellation succeeded or whether the
 447         // operation completed despite cancellation. On successful cancellation,
 448         // the operation is not deleted; instead, it becomes an operation with
 449         // an [Operation.error][google.longrunning.Operation.error] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1,
 450         // corresponding to `Code.CANCELLED`.
 451         CancelOperation(context.Context, *CancelOperationRequest) (*google_protobuf2.Empty, error)
 452 }
 453
 454 func RegisterOperationsServer(s *grpc.Server, srv OperationsServer) {
 455         s.RegisterService(&_Operations_serviceDesc, srv)
 456 }
 457
 458 func _Operations_ListOperations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 459         in := new(ListOperationsRequest)
 460         if err := dec(in); err != nil {
 461                 return nil, err
 462         }
 463         if interceptor == nil {
 464                 return srv.(OperationsServer).ListOperations(ctx, in)
 465         }
 466         info := &grpc.UnaryServerInfo{
 467                 Server:     srv,
 468                 FullMethod: "/google.longrunning.Operations/ListOperations",
 469         }
 470         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 471                 return srv.(OperationsServer).ListOperations(ctx, req.(*ListOperationsRequest))
 472         }
 473         return interceptor(ctx, in, info, handler)
 474 }
 475
 476 func _Operations_GetOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 477         in := new(GetOperationRequest)
 478         if err := dec(in); err != nil {
 479                 return nil, err
 480         }
 481         if interceptor == nil {
 482                 return srv.(OperationsServer).GetOperation(ctx, in)
 483         }
 484         info := &grpc.UnaryServerInfo{
 485                 Server:     srv,
 486                 FullMethod: "/google.longrunning.Operations/GetOperation",
 487         }
 488         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 489                 return srv.(OperationsServer).GetOperation(ctx, req.(*GetOperationRequest))
 490         }
 491         return interceptor(ctx, in, info, handler)
 492 }
 493
 494 func _Operations_DeleteOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 495         in := new(DeleteOperationRequest)
 496         if err := dec(in); err != nil {
 497                 return nil, err
 498         }
 499         if interceptor == nil {
 500                 return srv.(OperationsServer).DeleteOperation(ctx, in)
 501         }
 502         info := &grpc.UnaryServerInfo{
 503                 Server:     srv,
 504                 FullMethod: "/google.longrunning.Operations/DeleteOperation",
 505         }
 506         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 507                 return srv.(OperationsServer).DeleteOperation(ctx, req.(*DeleteOperationRequest))
 508         }
 509         return interceptor(ctx, in, info, handler)
 510 }
 511
 512 func _Operations_CancelOperation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 513         in := new(CancelOperationRequest)
 514         if err := dec(in); err != nil {
 515                 return nil, err
 516         }
 517         if interceptor == nil {
 518                 return srv.(OperationsServer).CancelOperation(ctx, in)
 519         }
 520         info := &grpc.UnaryServerInfo{
 521                 Server:     srv,
 522                 FullMethod: "/google.longrunning.Operations/CancelOperation",
 523         }
 524         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 525                 return srv.(OperationsServer).CancelOperation(ctx, req.(*CancelOperationRequest))
 526         }
 527         return interceptor(ctx, in, info, handler)
 528 }
 529
 530 var _Operations_serviceDesc = grpc.ServiceDesc{
 531         ServiceName: "google.longrunning.Operations",
 532         HandlerType: (*OperationsServer)(nil),
 533         Methods: []grpc.MethodDesc{
 534                 {
 535                         MethodName: "ListOperations",
 536                         Handler:    _Operations_ListOperations_Handler,
 537                 },
 538                 {
 539                         MethodName: "GetOperation",
 540                         Handler:    _Operations_GetOperation_Handler,
 541                 },
 542                 {
 543                         MethodName: "DeleteOperation",
 544                         Handler:    _Operations_DeleteOperation_Handler,
 545                 },
 546                 {
 547                         MethodName: "CancelOperation",
 548                         Handler:    _Operations_CancelOperation_Handler,
 549                 },
 550         },
 551         Streams:  []grpc.StreamDesc{},
 552         Metadata: "google/longrunning/operations.proto",
 553 }
 554
 555 func init() { proto.RegisterFile("google/longrunning/operations.proto", fileDescriptor0) }
 556
 557 var fileDescriptor0 = []byte{
 558         // 586 bytes of a gzipped FileDescriptorProto
 559         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xc1, 0x6e, 0xd3, 0x40,
 560         0x10, 0xad, 0xd3, 0x24, 0x4a, 0xa6, 0x40, 0xa4, 0x85, 0xba, 0xc6, 0x25, 0x22, 0x32, 0x08, 0x52,
 561         0xab, 0xb2, 0x21, 0xdc, 0x8a, 0x72, 0x20, 0x80, 0xda, 0x43, 0x25, 0x22, 0x97, 0x13, 0x97, 0x6a,
 562         0x9b, 0x4e, 0x2d, 0x0b, 0x67, 0xd7, 0xac, 0x37, 0xd0, 0x16, 0x55, 0x11, 0x1c, 0x38, 0x71, 0xe3,
 563         0x2f, 0xf8, 0x19, 0x0e, 0xfc, 0x02, 0x1f, 0x82, 0xbc, 0x76, 0x62, 0x93, 0x3a, 0x28, 0xb7, 0xf5,
 564         0xcc, 0x9b, 0x79, 0xf3, 0xde, 0xce, 0x1a, 0x1e, 0xf8, 0x9c, 0xfb, 0x21, 0xba, 0x21, 0x67, 0xbe,
 565         0x98, 0x30, 0x16, 0x30, 0xdf, 0xe5, 0x11, 0x0a, 0x2a, 0x03, 0xce, 0x62, 0x27, 0x12, 0x5c, 0x72,
 566         0x42, 0x52, 0x90, 0x53, 0x00, 0x99, 0xf7, 0xb2, 0x42, 0x1a, 0x05, 0x2e, 0x65, 0x8c, 0xcb, 0x62,
 567         0x85, 0x79, 0x37, 0xcb, 0xaa, 0xaf, 0x93, 0xc9, 0x99, 0x4b, 0xd9, 0x45, 0x96, 0xda, 0x5e, 0x4c,
 568         0xe1, 0x38, 0x92, 0xb3, 0xe4, 0x56, 0x96, 0x14, 0xd1, 0xc8, 0x8d, 0x25, 0x95, 0x93, 0xac, 0xa1,
 569         0xf5, 0x4b, 0x83, 0xe6, 0x9b, 0xd9, 0x5c, 0x84, 0x40, 0x95, 0xd1, 0x31, 0x1a, 0x5a, 0x47, 0xeb,
 570         0x36, 0x3d, 0x75, 0x26, 0x4f, 0xa0, 0x31, 0x46, 0x49, 0x4f, 0xa9, 0xa4, 0x46, 0xa5, 0xa3, 0x75,
 571         0x37, 0x7a, 0x77, 0x9c, 0x6c, 0xee, 0x19, 0x95, 0xf3, 0x82, 0x5d, 0x78, 0x73, 0x54, 0xd2, 0xe5,
 572         0x94, 0x33, 0x34, 0xd6, 0x3b, 0x5a, 0xb7, 0xe1, 0xa9, 0x33, 0xb1, 0xa1, 0x86, 0x42, 0x70, 0x61,
 573         0x54, 0x55, 0x0b, 0x32, 0x6b, 0x21, 0xa2, 0x91, 0x73, 0xa4, 0x06, 0x3a, 0x58, 0xf3, 0x52, 0x08,
 574         0xe9, 0x41, 0x43, 0x60, 0x1c, 0x71, 0x16, 0xa3, 0x51, 0x5b, 0xce, 0x78, 0xb0, 0xe6, 0xcd, 0x71,
 575         0x83, 0x06, 0xd4, 0x05, 0xc6, 0x93, 0x50, 0x5a, 0x3b, 0x70, 0x7b, 0x1f, 0xe5, 0x5c, 0x93, 0x87,
 576         0x1f, 0x26, 0x18, 0xcb, 0x32, 0x69, 0xd6, 0x14, 0x36, 0x0f, 0x83, 0x38, 0xc7, 0xc6, 0x8b, 0xe0,
 577         0x6a, 0xc1, 0x07, 0x1d, 0xea, 0x67, 0x41, 0x28, 0x51, 0x64, 0x2d, 0xb2, 0x2f, 0xb2, 0x0d, 0xcd,
 578         0x88, 0xfa, 0x78, 0x1c, 0x07, 0x97, 0xa8, 0x0c, 0xaa, 0x79, 0x8d, 0x24, 0x70, 0x14, 0x5c, 0x22,
 579         0x69, 0x03, 0xa8, 0xa4, 0xe4, 0xef, 0x91, 0x29, 0x43, 0x9a, 0x9e, 0x82, 0xbf, 0x4d, 0x02, 0xd6,
 580         0x14, 0xf4, 0xc5, 0x01, 0x52, 0x3d, 0xa4, 0x0f, 0x90, 0xaf, 0x8b, 0xa1, 0x75, 0xd6, 0xbb, 0x1b,
 581         0xbd, 0xb6, 0x73, 0x7d, 0x5f, 0x9c, 0x5c, 0x68, 0xa1, 0x80, 0x3c, 0x82, 0x16, 0xc3, 0x73, 0x79,
 582         0x5c, 0x20, 0xaf, 0x28, 0xf2, 0x9b, 0x49, 0x78, 0x38, 0x1f, 0x60, 0x17, 0xf4, 0x97, 0x94, 0x8d,
 583         0x30, 0x5c, 0xc9, 0xaf, 0x5d, 0xd0, 0x5f, 0x61, 0x88, 0x12, 0x57, 0x41, 0xf7, 0xbe, 0x57, 0x01,
 584         0x72, 0x65, 0xe4, 0x9b, 0x06, 0xb7, 0xfe, 0x15, 0x4b, 0x76, 0xca, 0x04, 0x95, 0xde, 0x88, 0x69,
 585         0xaf, 0x02, 0x4d, 0xbd, 0xb3, 0xda, 0x5f, 0x7f, 0xff, 0xf9, 0x51, 0xd9, 0x22, 0x9b, 0xee, 0xc7,
 586         0xa7, 0xee, 0xe7, 0x64, 0x96, 0x7e, 0x6e, 0xcd, 0x15, 0x39, 0x87, 0x1b, 0xc5, 0x05, 0x21, 0x8f,
 587         0xcb, 0x5a, 0x97, 0xac, 0x90, 0xf9, 0x7f, 0xff, 0xad, 0x8e, 0xa2, 0x35, 0x89, 0x51, 0x46, 0xeb,
 588         0xda, 0xf6, 0x15, 0xf9, 0x04, 0xad, 0x05, 0xff, 0x48, 0xa9, 0xae, 0x72, 0x93, 0x4d, 0xfd, 0xda,
 589         0x2b, 0x78, 0x9d, 0x3c, 0xf1, 0x19, 0xb1, 0xbd, 0x9c, 0xf8, 0x8b, 0x06, 0xad, 0x85, 0x7b, 0x2e,
 590         0x67, 0x2e, 0x5f, 0x86, 0xa5, 0xcc, 0xb6, 0x62, 0x7e, 0x68, 0xdd, 0x5f, 0xc6, 0xbc, 0x37, 0x52,
 591         0x0d, 0xf7, 0x34, 0x7b, 0x30, 0x05, 0x7d, 0xc4, 0xc7, 0x25, 0xa4, 0x83, 0x56, 0x7e, 0x87, 0xc3,
 592         0xa4, 0xff, 0x50, 0x7b, 0xd7, 0xcf, 0x60, 0x3e, 0x0f, 0x29, 0xf3, 0x1d, 0x2e, 0x7c, 0xd7, 0x47,
 593         0xa6, 0xd8, 0xdd, 0x34, 0x45, 0xa3, 0x20, 0x2e, 0xfe, 0x5d, 0x9f, 0x17, 0xce, 0x3f, 0x2b, 0x64,
 594         0x3f, 0xad, 0x3f, 0xe4, 0xcc, 0xf7, 0xd2, 0xe0, 0x49, 0x5d, 0x95, 0x3f, 0xfb, 0x1b, 0x00, 0x00,
 595         0xff, 0xff, 0x69, 0x4c, 0xa6, 0x3e, 0x9b, 0x05, 0x00, 0x00,
 596 }