vendor/github.com/hashicorp/go-plugin/test/grpc/test.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: test.proto
   3
   4 /*
   5 Package grpctest is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         test.proto
   9
  10 It has these top-level messages:
  11         TestRequest
  12         TestResponse
  13         PrintKVRequest
  14         PrintKVResponse
  15         BidirectionalRequest
  16         BidirectionalResponse
  17         PingRequest
  18         PongResponse
  19 */
  20 package grpctest
  21
  22 import proto "github.com/golang/protobuf/proto"
  23 import fmt "fmt"
  24 import math "math"
  25
  26 import (
  27         context "golang.org/x/net/context"
  28         grpc "google.golang.org/grpc"
  29 )
  30
  31 // Reference imports to suppress errors if they are not otherwise used.
  32 var _ = proto.Marshal
  33 var _ = fmt.Errorf
  34 var _ = math.Inf
  35
  36 // This is a compile-time assertion to ensure that this generated file
  37 // is compatible with the proto package it is being compiled against.
  38 // A compilation error at this line likely means your copy of the
  39 // proto package needs to be updated.
  40 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  41
  42 type TestRequest struct {
  43         Input int32 `protobuf:"varint,1,opt,name=Input" json:"Input,omitempty"`
  44 }
  45
  46 func (m *TestRequest) Reset()                    { *m = TestRequest{} }
  47 func (m *TestRequest) String() string            { return proto.CompactTextString(m) }
  48 func (*TestRequest) ProtoMessage()               {}
  49 func (*TestRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  50
  51 func (m *TestRequest) GetInput() int32 {
  52         if m != nil {
  53                 return m.Input
  54         }
  55         return 0
  56 }
  57
  58 type TestResponse struct {
  59         Output int32 `protobuf:"varint,2,opt,name=Output" json:"Output,omitempty"`
  60 }
  61
  62 func (m *TestResponse) Reset()                    { *m = TestResponse{} }
  63 func (m *TestResponse) String() string            { return proto.CompactTextString(m) }
  64 func (*TestResponse) ProtoMessage()               {}
  65 func (*TestResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
  66
  67 func (m *TestResponse) GetOutput() int32 {
  68         if m != nil {
  69                 return m.Output
  70         }
  71         return 0
  72 }
  73
  74 type PrintKVRequest struct {
  75         Key string `protobuf:"bytes,1,opt,name=Key" json:"Key,omitempty"`
  76         // Types that are valid to be assigned to Value:
  77         //      *PrintKVRequest_ValueString
  78         //      *PrintKVRequest_ValueInt
  79         Value isPrintKVRequest_Value `protobuf_oneof:"Value"`
  80 }
  81
  82 func (m *PrintKVRequest) Reset()                    { *m = PrintKVRequest{} }
  83 func (m *PrintKVRequest) String() string            { return proto.CompactTextString(m) }
  84 func (*PrintKVRequest) ProtoMessage()               {}
  85 func (*PrintKVRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
  86
  87 type isPrintKVRequest_Value interface{ isPrintKVRequest_Value() }
  88
  89 type PrintKVRequest_ValueString struct {
  90         ValueString string `protobuf:"bytes,2,opt,name=ValueString,oneof"`
  91 }
  92 type PrintKVRequest_ValueInt struct {
  93         ValueInt int32 `protobuf:"varint,3,opt,name=ValueInt,oneof"`
  94 }
  95
  96 func (*PrintKVRequest_ValueString) isPrintKVRequest_Value() {}
  97 func (*PrintKVRequest_ValueInt) isPrintKVRequest_Value()    {}
  98
  99 func (m *PrintKVRequest) GetValue() isPrintKVRequest_Value {
 100         if m != nil {
 101                 return m.Value
 102         }
 103         return nil
 104 }
 105
 106 func (m *PrintKVRequest) GetKey() string {
 107         if m != nil {
 108                 return m.Key
 109         }
 110         return ""
 111 }
 112
 113 func (m *PrintKVRequest) GetValueString() string {
 114         if x, ok := m.GetValue().(*PrintKVRequest_ValueString); ok {
 115                 return x.ValueString
 116         }
 117         return ""
 118 }
 119
 120 func (m *PrintKVRequest) GetValueInt() int32 {
 121         if x, ok := m.GetValue().(*PrintKVRequest_ValueInt); ok {
 122                 return x.ValueInt
 123         }
 124         return 0
 125 }
 126
 127 // XXX_OneofFuncs is for the internal use of the proto package.
 128 func (*PrintKVRequest) 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{}) {
 129         return _PrintKVRequest_OneofMarshaler, _PrintKVRequest_OneofUnmarshaler, _PrintKVRequest_OneofSizer, []interface{}{
 130                 (*PrintKVRequest_ValueString)(nil),
 131                 (*PrintKVRequest_ValueInt)(nil),
 132         }
 133 }
 134
 135 func _PrintKVRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 136         m := msg.(*PrintKVRequest)
 137         // Value
 138         switch x := m.Value.(type) {
 139         case *PrintKVRequest_ValueString:
 140                 b.EncodeVarint(2<<3 | proto.WireBytes)
 141                 b.EncodeStringBytes(x.ValueString)
 142         case *PrintKVRequest_ValueInt:
 143                 b.EncodeVarint(3<<3 | proto.WireVarint)
 144                 b.EncodeVarint(uint64(x.ValueInt))
 145         case nil:
 146         default:
 147                 return fmt.Errorf("PrintKVRequest.Value has unexpected type %T", x)
 148         }
 149         return nil
 150 }
 151
 152 func _PrintKVRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 153         m := msg.(*PrintKVRequest)
 154         switch tag {
 155         case 2: // Value.ValueString
 156                 if wire != proto.WireBytes {
 157                         return true, proto.ErrInternalBadWireType
 158                 }
 159                 x, err := b.DecodeStringBytes()
 160                 m.Value = &PrintKVRequest_ValueString{x}
 161                 return true, err
 162         case 3: // Value.ValueInt
 163                 if wire != proto.WireVarint {
 164                         return true, proto.ErrInternalBadWireType
 165                 }
 166                 x, err := b.DecodeVarint()
 167                 m.Value = &PrintKVRequest_ValueInt{int32(x)}
 168                 return true, err
 169         default:
 170                 return false, nil
 171         }
 172 }
 173
 174 func _PrintKVRequest_OneofSizer(msg proto.Message) (n int) {
 175         m := msg.(*PrintKVRequest)
 176         // Value
 177         switch x := m.Value.(type) {
 178         case *PrintKVRequest_ValueString:
 179                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 180                 n += proto.SizeVarint(uint64(len(x.ValueString)))
 181                 n += len(x.ValueString)
 182         case *PrintKVRequest_ValueInt:
 183                 n += proto.SizeVarint(3<<3 | proto.WireVarint)
 184                 n += proto.SizeVarint(uint64(x.ValueInt))
 185         case nil:
 186         default:
 187                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 188         }
 189         return n
 190 }
 191
 192 type PrintKVResponse struct {
 193 }
 194
 195 func (m *PrintKVResponse) Reset()                    { *m = PrintKVResponse{} }
 196 func (m *PrintKVResponse) String() string            { return proto.CompactTextString(m) }
 197 func (*PrintKVResponse) ProtoMessage()               {}
 198 func (*PrintKVResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 199
 200 type BidirectionalRequest struct {
 201         Id uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
 202 }
 203
 204 func (m *BidirectionalRequest) Reset()                    { *m = BidirectionalRequest{} }
 205 func (m *BidirectionalRequest) String() string            { return proto.CompactTextString(m) }
 206 func (*BidirectionalRequest) ProtoMessage()               {}
 207 func (*BidirectionalRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 208
 209 func (m *BidirectionalRequest) GetId() uint32 {
 210         if m != nil {
 211                 return m.Id
 212         }
 213         return 0
 214 }
 215
 216 type BidirectionalResponse struct {
 217         Id uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
 218 }
 219
 220 func (m *BidirectionalResponse) Reset()                    { *m = BidirectionalResponse{} }
 221 func (m *BidirectionalResponse) String() string            { return proto.CompactTextString(m) }
 222 func (*BidirectionalResponse) ProtoMessage()               {}
 223 func (*BidirectionalResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 224
 225 func (m *BidirectionalResponse) GetId() uint32 {
 226         if m != nil {
 227                 return m.Id
 228         }
 229         return 0
 230 }
 231
 232 type PingRequest struct {
 233 }
 234
 235 func (m *PingRequest) Reset()                    { *m = PingRequest{} }
 236 func (m *PingRequest) String() string            { return proto.CompactTextString(m) }
 237 func (*PingRequest) ProtoMessage()               {}
 238 func (*PingRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 239
 240 type PongResponse struct {
 241         Msg string `protobuf:"bytes,1,opt,name=msg" json:"msg,omitempty"`
 242 }
 243
 244 func (m *PongResponse) Reset()                    { *m = PongResponse{} }
 245 func (m *PongResponse) String() string            { return proto.CompactTextString(m) }
 246 func (*PongResponse) ProtoMessage()               {}
 247 func (*PongResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 248
 249 func (m *PongResponse) GetMsg() string {
 250         if m != nil {
 251                 return m.Msg
 252         }
 253         return ""
 254 }
 255
 256 func init() {
 257         proto.RegisterType((*TestRequest)(nil), "grpctest.TestRequest")
 258         proto.RegisterType((*TestResponse)(nil), "grpctest.TestResponse")
 259         proto.RegisterType((*PrintKVRequest)(nil), "grpctest.PrintKVRequest")
 260         proto.RegisterType((*PrintKVResponse)(nil), "grpctest.PrintKVResponse")
 261         proto.RegisterType((*BidirectionalRequest)(nil), "grpctest.BidirectionalRequest")
 262         proto.RegisterType((*BidirectionalResponse)(nil), "grpctest.BidirectionalResponse")
 263         proto.RegisterType((*PingRequest)(nil), "grpctest.PingRequest")
 264         proto.RegisterType((*PongResponse)(nil), "grpctest.PongResponse")
 265 }
 266
 267 // Reference imports to suppress errors if they are not otherwise used.
 268 var _ context.Context
 269 var _ grpc.ClientConn
 270
 271 // This is a compile-time assertion to ensure that this generated file
 272 // is compatible with the grpc package it is being compiled against.
 273 const _ = grpc.SupportPackageIsVersion4
 274
 275 // Client API for Test service
 276
 277 type TestClient interface {
 278         Double(ctx context.Context, in *TestRequest, opts ...grpc.CallOption) (*TestResponse, error)
 279         PrintKV(ctx context.Context, in *PrintKVRequest, opts ...grpc.CallOption) (*PrintKVResponse, error)
 280         Bidirectional(ctx context.Context, in *BidirectionalRequest, opts ...grpc.CallOption) (*BidirectionalResponse, error)
 281         Stream(ctx context.Context, opts ...grpc.CallOption) (Test_StreamClient, error)
 282 }
 283
 284 type testClient struct {
 285         cc *grpc.ClientConn
 286 }
 287
 288 func NewTestClient(cc *grpc.ClientConn) TestClient {
 289         return &testClient{cc}
 290 }
 291
 292 func (c *testClient) Double(ctx context.Context, in *TestRequest, opts ...grpc.CallOption) (*TestResponse, error) {
 293         out := new(TestResponse)
 294         err := grpc.Invoke(ctx, "/grpctest.Test/Double", in, out, c.cc, opts...)
 295         if err != nil {
 296                 return nil, err
 297         }
 298         return out, nil
 299 }
 300
 301 func (c *testClient) PrintKV(ctx context.Context, in *PrintKVRequest, opts ...grpc.CallOption) (*PrintKVResponse, error) {
 302         out := new(PrintKVResponse)
 303         err := grpc.Invoke(ctx, "/grpctest.Test/PrintKV", in, out, c.cc, opts...)
 304         if err != nil {
 305                 return nil, err
 306         }
 307         return out, nil
 308 }
 309
 310 func (c *testClient) Bidirectional(ctx context.Context, in *BidirectionalRequest, opts ...grpc.CallOption) (*BidirectionalResponse, error) {
 311         out := new(BidirectionalResponse)
 312         err := grpc.Invoke(ctx, "/grpctest.Test/Bidirectional", in, out, c.cc, opts...)
 313         if err != nil {
 314                 return nil, err
 315         }
 316         return out, nil
 317 }
 318
 319 func (c *testClient) Stream(ctx context.Context, opts ...grpc.CallOption) (Test_StreamClient, error) {
 320         stream, err := grpc.NewClientStream(ctx, &_Test_serviceDesc.Streams[0], c.cc, "/grpctest.Test/Stream", opts...)
 321         if err != nil {
 322                 return nil, err
 323         }
 324         x := &testStreamClient{stream}
 325         return x, nil
 326 }
 327
 328 type Test_StreamClient interface {
 329         Send(*TestRequest) error
 330         Recv() (*TestResponse, error)
 331         grpc.ClientStream
 332 }
 333
 334 type testStreamClient struct {
 335         grpc.ClientStream
 336 }
 337
 338 func (x *testStreamClient) Send(m *TestRequest) error {
 339         return x.ClientStream.SendMsg(m)
 340 }
 341
 342 func (x *testStreamClient) Recv() (*TestResponse, error) {
 343         m := new(TestResponse)
 344         if err := x.ClientStream.RecvMsg(m); err != nil {
 345                 return nil, err
 346         }
 347         return m, nil
 348 }
 349
 350 // Server API for Test service
 351
 352 type TestServer interface {
 353         Double(context.Context, *TestRequest) (*TestResponse, error)
 354         PrintKV(context.Context, *PrintKVRequest) (*PrintKVResponse, error)
 355         Bidirectional(context.Context, *BidirectionalRequest) (*BidirectionalResponse, error)
 356         Stream(Test_StreamServer) error
 357 }
 358
 359 func RegisterTestServer(s *grpc.Server, srv TestServer) {
 360         s.RegisterService(&_Test_serviceDesc, srv)
 361 }
 362
 363 func _Test_Double_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 364         in := new(TestRequest)
 365         if err := dec(in); err != nil {
 366                 return nil, err
 367         }
 368         if interceptor == nil {
 369                 return srv.(TestServer).Double(ctx, in)
 370         }
 371         info := &grpc.UnaryServerInfo{
 372                 Server:     srv,
 373                 FullMethod: "/grpctest.Test/Double",
 374         }
 375         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 376                 return srv.(TestServer).Double(ctx, req.(*TestRequest))
 377         }
 378         return interceptor(ctx, in, info, handler)
 379 }
 380
 381 func _Test_PrintKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 382         in := new(PrintKVRequest)
 383         if err := dec(in); err != nil {
 384                 return nil, err
 385         }
 386         if interceptor == nil {
 387                 return srv.(TestServer).PrintKV(ctx, in)
 388         }
 389         info := &grpc.UnaryServerInfo{
 390                 Server:     srv,
 391                 FullMethod: "/grpctest.Test/PrintKV",
 392         }
 393         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 394                 return srv.(TestServer).PrintKV(ctx, req.(*PrintKVRequest))
 395         }
 396         return interceptor(ctx, in, info, handler)
 397 }
 398
 399 func _Test_Bidirectional_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 400         in := new(BidirectionalRequest)
 401         if err := dec(in); err != nil {
 402                 return nil, err
 403         }
 404         if interceptor == nil {
 405                 return srv.(TestServer).Bidirectional(ctx, in)
 406         }
 407         info := &grpc.UnaryServerInfo{
 408                 Server:     srv,
 409                 FullMethod: "/grpctest.Test/Bidirectional",
 410         }
 411         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 412                 return srv.(TestServer).Bidirectional(ctx, req.(*BidirectionalRequest))
 413         }
 414         return interceptor(ctx, in, info, handler)
 415 }
 416
 417 func _Test_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
 418         return srv.(TestServer).Stream(&testStreamServer{stream})
 419 }
 420
 421 type Test_StreamServer interface {
 422         Send(*TestResponse) error
 423         Recv() (*TestRequest, error)
 424         grpc.ServerStream
 425 }
 426
 427 type testStreamServer struct {
 428         grpc.ServerStream
 429 }
 430
 431 func (x *testStreamServer) Send(m *TestResponse) error {
 432         return x.ServerStream.SendMsg(m)
 433 }
 434
 435 func (x *testStreamServer) Recv() (*TestRequest, error) {
 436         m := new(TestRequest)
 437         if err := x.ServerStream.RecvMsg(m); err != nil {
 438                 return nil, err
 439         }
 440         return m, nil
 441 }
 442
 443 var _Test_serviceDesc = grpc.ServiceDesc{
 444         ServiceName: "grpctest.Test",
 445         HandlerType: (*TestServer)(nil),
 446         Methods: []grpc.MethodDesc{
 447                 {
 448                         MethodName: "Double",
 449                         Handler:    _Test_Double_Handler,
 450                 },
 451                 {
 452                         MethodName: "PrintKV",
 453                         Handler:    _Test_PrintKV_Handler,
 454                 },
 455                 {
 456                         MethodName: "Bidirectional",
 457                         Handler:    _Test_Bidirectional_Handler,
 458                 },
 459         },
 460         Streams: []grpc.StreamDesc{
 461                 {
 462                         StreamName:    "Stream",
 463                         Handler:       _Test_Stream_Handler,
 464                         ServerStreams: true,
 465                         ClientStreams: true,
 466                 },
 467         },
 468         Metadata: "test.proto",
 469 }
 470
 471 // Client API for PingPong service
 472
 473 type PingPongClient interface {
 474         Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error)
 475 }
 476
 477 type pingPongClient struct {
 478         cc *grpc.ClientConn
 479 }
 480
 481 func NewPingPongClient(cc *grpc.ClientConn) PingPongClient {
 482         return &pingPongClient{cc}
 483 }
 484
 485 func (c *pingPongClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) {
 486         out := new(PongResponse)
 487         err := grpc.Invoke(ctx, "/grpctest.PingPong/Ping", in, out, c.cc, opts...)
 488         if err != nil {
 489                 return nil, err
 490         }
 491         return out, nil
 492 }
 493
 494 // Server API for PingPong service
 495
 496 type PingPongServer interface {
 497         Ping(context.Context, *PingRequest) (*PongResponse, error)
 498 }
 499
 500 func RegisterPingPongServer(s *grpc.Server, srv PingPongServer) {
 501         s.RegisterService(&_PingPong_serviceDesc, srv)
 502 }
 503
 504 func _PingPong_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 505         in := new(PingRequest)
 506         if err := dec(in); err != nil {
 507                 return nil, err
 508         }
 509         if interceptor == nil {
 510                 return srv.(PingPongServer).Ping(ctx, in)
 511         }
 512         info := &grpc.UnaryServerInfo{
 513                 Server:     srv,
 514                 FullMethod: "/grpctest.PingPong/Ping",
 515         }
 516         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 517                 return srv.(PingPongServer).Ping(ctx, req.(*PingRequest))
 518         }
 519         return interceptor(ctx, in, info, handler)
 520 }
 521
 522 var _PingPong_serviceDesc = grpc.ServiceDesc{
 523         ServiceName: "grpctest.PingPong",
 524         HandlerType: (*PingPongServer)(nil),
 525         Methods: []grpc.MethodDesc{
 526                 {
 527                         MethodName: "Ping",
 528                         Handler:    _PingPong_Ping_Handler,
 529                 },
 530         },
 531         Streams:  []grpc.StreamDesc{},
 532         Metadata: "test.proto",
 533 }
 534
 535 func init() { proto.RegisterFile("test.proto", fileDescriptor0) }
 536
 537 var fileDescriptor0 = []byte{
 538         // 355 bytes of a gzipped FileDescriptorProto
 539         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xcd, 0x4e, 0xc2, 0x40,
 540         0x14, 0x85, 0xdb, 0x02, 0x05, 0x2e, 0x3f, 0xe2, 0x04, 0x08, 0x12, 0xa3, 0x64, 0x4c, 0x90, 0x15,
 541         0x31, 0xb8, 0x30, 0x2e, 0x4c, 0x0c, 0xba, 0x80, 0xb0, 0x90, 0x0c, 0x86, 0x3d, 0x3f, 0x93, 0x66,
 542         0x12, 0x3a, 0xad, 0x9d, 0xe9, 0xc2, 0x17, 0xf1, 0x79, 0xcd, 0x0c, 0x6d, 0x19, 0x08, 0x2e, 0xdc,
 543         0xdd, 0x73, 0x7b, 0x72, 0xe6, 0x9e, 0x2f, 0x05, 0x90, 0x54, 0xc8, 0x61, 0x18, 0x05, 0x32, 0x40,
 544         0x25, 0x2f, 0x0a, 0x37, 0x4a, 0xe3, 0x3b, 0xa8, 0x7c, 0x52, 0x21, 0x09, 0xfd, 0x8a, 0xa9, 0x90,
 545         0xa8, 0x09, 0x85, 0x29, 0x0f, 0x63, 0xd9, 0xb1, 0x7b, 0xf6, 0xa0, 0x40, 0xf6, 0x02, 0xf7, 0xa1,
 546         0xba, 0x37, 0x89, 0x30, 0xe0, 0x82, 0xa2, 0x36, 0xb8, 0x1f, 0xb1, 0x54, 0x36, 0x47, 0xdb, 0x12,
 547         0x85, 0x7d, 0xa8, 0xcf, 0x23, 0xc6, 0xe5, 0x6c, 0x99, 0xe6, 0x35, 0x20, 0x37, 0xa3, 0xdf, 0x3a,
 548         0xad, 0x4c, 0xd4, 0x88, 0x30, 0x54, 0x96, 0xab, 0x5d, 0x4c, 0x17, 0x32, 0x62, 0xdc, 0xd3, 0x01,
 549         0xe5, 0x89, 0x45, 0xcc, 0x25, 0xba, 0x86, 0x92, 0x96, 0x53, 0x2e, 0x3b, 0x39, 0xf5, 0xc2, 0xc4,
 550         0x22, 0xd9, 0x66, 0x5c, 0x84, 0x82, 0x9e, 0xf1, 0x25, 0x5c, 0x64, 0xcf, 0xed, 0x2f, 0xc3, 0x7d,
 551         0x68, 0x8e, 0xd9, 0x96, 0x45, 0x74, 0x23, 0x59, 0xc0, 0x57, 0xbb, 0xf4, 0x8e, 0x3a, 0x38, 0x6c,
 552         0xab, 0xcf, 0xa8, 0x11, 0x87, 0x6d, 0xf1, 0x3d, 0xb4, 0x4e, 0x7c, 0x49, 0xb5, 0x53, 0x63, 0x0d,
 553         0x2a, 0x73, 0xc6, 0xbd, 0x24, 0x07, 0xf7, 0xa0, 0x3a, 0x0f, 0x94, 0x4c, 0xec, 0x0d, 0xc8, 0xf9,
 554         0xc2, 0x4b, 0xfb, 0xf9, 0xc2, 0x1b, 0xfd, 0x38, 0x90, 0x57, 0xb0, 0xd0, 0x33, 0xb8, 0xef, 0x41,
 555         0xbc, 0xde, 0x51, 0xd4, 0x1a, 0xa6, 0xb8, 0x87, 0x06, 0xeb, 0x6e, 0xfb, 0x74, 0x9d, 0x74, 0xb0,
 556         0xd0, 0x2b, 0x14, 0x93, 0x62, 0xa8, 0x73, 0x30, 0x1d, 0xa3, 0xed, 0x5e, 0x9d, 0xf9, 0x92, 0x25,
 557         0x10, 0xa8, 0x1d, 0xf5, 0x43, 0x37, 0x07, 0xf7, 0x39, 0x40, 0xdd, 0xdb, 0x3f, 0xbf, 0x67, 0x99,
 558         0x2f, 0xe0, 0x2e, 0x64, 0x44, 0x57, 0xfe, 0xbf, 0x0b, 0x0d, 0xec, 0x07, 0x7b, 0xf4, 0x06, 0x25,
 559         0x45, 0x52, 0xe1, 0x43, 0x4f, 0x90, 0x57, 0xb3, 0x19, 0x64, 0x50, 0x36, 0x83, 0x4c, 0xda, 0xd8,
 560         0x5a, 0xbb, 0xfa, 0xff, 0x7d, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x59, 0x20, 0xc7, 0xcd,
 561         0x02, 0x00, 0x00,
 562 }