vendor/google.golang.org/grpc/benchmark/grpc_testing/messages.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: messages.proto
   3
   4 package grpc_testing
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9
  10 // Reference imports to suppress errors if they are not otherwise used.
  11 var _ = proto.Marshal
  12 var _ = fmt.Errorf
  13 var _ = math.Inf
  14
  15 // The type of payload that should be returned.
  16 type PayloadType int32
  17
  18 const (
  19         // Compressable text format.
  20         PayloadType_COMPRESSABLE PayloadType = 0
  21         // Uncompressable binary format.
  22         PayloadType_UNCOMPRESSABLE PayloadType = 1
  23         // Randomly chosen from all other formats defined in this enum.
  24         PayloadType_RANDOM PayloadType = 2
  25 )
  26
  27 var PayloadType_name = map[int32]string{
  28         0: "COMPRESSABLE",
  29         1: "UNCOMPRESSABLE",
  30         2: "RANDOM",
  31 }
  32 var PayloadType_value = map[string]int32{
  33         "COMPRESSABLE":   0,
  34         "UNCOMPRESSABLE": 1,
  35         "RANDOM":         2,
  36 }
  37
  38 func (x PayloadType) String() string {
  39         return proto.EnumName(PayloadType_name, int32(x))
  40 }
  41 func (PayloadType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
  42
  43 // Compression algorithms
  44 type CompressionType int32
  45
  46 const (
  47         // No compression
  48         CompressionType_NONE    CompressionType = 0
  49         CompressionType_GZIP    CompressionType = 1
  50         CompressionType_DEFLATE CompressionType = 2
  51 )
  52
  53 var CompressionType_name = map[int32]string{
  54         0: "NONE",
  55         1: "GZIP",
  56         2: "DEFLATE",
  57 }
  58 var CompressionType_value = map[string]int32{
  59         "NONE":    0,
  60         "GZIP":    1,
  61         "DEFLATE": 2,
  62 }
  63
  64 func (x CompressionType) String() string {
  65         return proto.EnumName(CompressionType_name, int32(x))
  66 }
  67 func (CompressionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
  68
  69 // A block of data, to simply increase gRPC message size.
  70 type Payload struct {
  71         // The type of data in body.
  72         Type PayloadType `protobuf:"varint,1,opt,name=type,enum=grpc.testing.PayloadType" json:"type,omitempty"`
  73         // Primary contents of payload.
  74         Body []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
  75 }
  76
  77 func (m *Payload) Reset()                    { *m = Payload{} }
  78 func (m *Payload) String() string            { return proto.CompactTextString(m) }
  79 func (*Payload) ProtoMessage()               {}
  80 func (*Payload) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
  81
  82 func (m *Payload) GetType() PayloadType {
  83         if m != nil {
  84                 return m.Type
  85         }
  86         return PayloadType_COMPRESSABLE
  87 }
  88
  89 func (m *Payload) GetBody() []byte {
  90         if m != nil {
  91                 return m.Body
  92         }
  93         return nil
  94 }
  95
  96 // A protobuf representation for grpc status. This is used by test
  97 // clients to specify a status that the server should attempt to return.
  98 type EchoStatus struct {
  99         Code    int32  `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
 100         Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
 101 }
 102
 103 func (m *EchoStatus) Reset()                    { *m = EchoStatus{} }
 104 func (m *EchoStatus) String() string            { return proto.CompactTextString(m) }
 105 func (*EchoStatus) ProtoMessage()               {}
 106 func (*EchoStatus) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
 107
 108 func (m *EchoStatus) GetCode() int32 {
 109         if m != nil {
 110                 return m.Code
 111         }
 112         return 0
 113 }
 114
 115 func (m *EchoStatus) GetMessage() string {
 116         if m != nil {
 117                 return m.Message
 118         }
 119         return ""
 120 }
 121
 122 // Unary request.
 123 type SimpleRequest struct {
 124         // Desired payload type in the response from the server.
 125         // If response_type is RANDOM, server randomly chooses one from other formats.
 126         ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,json=responseType,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
 127         // Desired payload size in the response from the server.
 128         // If response_type is COMPRESSABLE, this denotes the size before compression.
 129         ResponseSize int32 `protobuf:"varint,2,opt,name=response_size,json=responseSize" json:"response_size,omitempty"`
 130         // Optional input payload sent along with the request.
 131         Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
 132         // Whether SimpleResponse should include username.
 133         FillUsername bool `protobuf:"varint,4,opt,name=fill_username,json=fillUsername" json:"fill_username,omitempty"`
 134         // Whether SimpleResponse should include OAuth scope.
 135         FillOauthScope bool `protobuf:"varint,5,opt,name=fill_oauth_scope,json=fillOauthScope" json:"fill_oauth_scope,omitempty"`
 136         // Compression algorithm to be used by the server for the response (stream)
 137         ResponseCompression CompressionType `protobuf:"varint,6,opt,name=response_compression,json=responseCompression,enum=grpc.testing.CompressionType" json:"response_compression,omitempty"`
 138         // Whether server should return a given status
 139         ResponseStatus *EchoStatus `protobuf:"bytes,7,opt,name=response_status,json=responseStatus" json:"response_status,omitempty"`
 140 }
 141
 142 func (m *SimpleRequest) Reset()                    { *m = SimpleRequest{} }
 143 func (m *SimpleRequest) String() string            { return proto.CompactTextString(m) }
 144 func (*SimpleRequest) ProtoMessage()               {}
 145 func (*SimpleRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
 146
 147 func (m *SimpleRequest) GetResponseType() PayloadType {
 148         if m != nil {
 149                 return m.ResponseType
 150         }
 151         return PayloadType_COMPRESSABLE
 152 }
 153
 154 func (m *SimpleRequest) GetResponseSize() int32 {
 155         if m != nil {
 156                 return m.ResponseSize
 157         }
 158         return 0
 159 }
 160
 161 func (m *SimpleRequest) GetPayload() *Payload {
 162         if m != nil {
 163                 return m.Payload
 164         }
 165         return nil
 166 }
 167
 168 func (m *SimpleRequest) GetFillUsername() bool {
 169         if m != nil {
 170                 return m.FillUsername
 171         }
 172         return false
 173 }
 174
 175 func (m *SimpleRequest) GetFillOauthScope() bool {
 176         if m != nil {
 177                 return m.FillOauthScope
 178         }
 179         return false
 180 }
 181
 182 func (m *SimpleRequest) GetResponseCompression() CompressionType {
 183         if m != nil {
 184                 return m.ResponseCompression
 185         }
 186         return CompressionType_NONE
 187 }
 188
 189 func (m *SimpleRequest) GetResponseStatus() *EchoStatus {
 190         if m != nil {
 191                 return m.ResponseStatus
 192         }
 193         return nil
 194 }
 195
 196 // Unary response, as configured by the request.
 197 type SimpleResponse struct {
 198         // Payload to increase message size.
 199         Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
 200         // The user the request came from, for verifying authentication was
 201         // successful when the client expected it.
 202         Username string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"`
 203         // OAuth scope.
 204         OauthScope string `protobuf:"bytes,3,opt,name=oauth_scope,json=oauthScope" json:"oauth_scope,omitempty"`
 205 }
 206
 207 func (m *SimpleResponse) Reset()                    { *m = SimpleResponse{} }
 208 func (m *SimpleResponse) String() string            { return proto.CompactTextString(m) }
 209 func (*SimpleResponse) ProtoMessage()               {}
 210 func (*SimpleResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 211
 212 func (m *SimpleResponse) GetPayload() *Payload {
 213         if m != nil {
 214                 return m.Payload
 215         }
 216         return nil
 217 }
 218
 219 func (m *SimpleResponse) GetUsername() string {
 220         if m != nil {
 221                 return m.Username
 222         }
 223         return ""
 224 }
 225
 226 func (m *SimpleResponse) GetOauthScope() string {
 227         if m != nil {
 228                 return m.OauthScope
 229         }
 230         return ""
 231 }
 232
 233 // Client-streaming request.
 234 type StreamingInputCallRequest struct {
 235         // Optional input payload sent along with the request.
 236         Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
 237 }
 238
 239 func (m *StreamingInputCallRequest) Reset()                    { *m = StreamingInputCallRequest{} }
 240 func (m *StreamingInputCallRequest) String() string            { return proto.CompactTextString(m) }
 241 func (*StreamingInputCallRequest) ProtoMessage()               {}
 242 func (*StreamingInputCallRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
 243
 244 func (m *StreamingInputCallRequest) GetPayload() *Payload {
 245         if m != nil {
 246                 return m.Payload
 247         }
 248         return nil
 249 }
 250
 251 // Client-streaming response.
 252 type StreamingInputCallResponse struct {
 253         // Aggregated size of payloads received from the client.
 254         AggregatedPayloadSize int32 `protobuf:"varint,1,opt,name=aggregated_payload_size,json=aggregatedPayloadSize" json:"aggregated_payload_size,omitempty"`
 255 }
 256
 257 func (m *StreamingInputCallResponse) Reset()                    { *m = StreamingInputCallResponse{} }
 258 func (m *StreamingInputCallResponse) String() string            { return proto.CompactTextString(m) }
 259 func (*StreamingInputCallResponse) ProtoMessage()               {}
 260 func (*StreamingInputCallResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
 261
 262 func (m *StreamingInputCallResponse) GetAggregatedPayloadSize() int32 {
 263         if m != nil {
 264                 return m.AggregatedPayloadSize
 265         }
 266         return 0
 267 }
 268
 269 // Configuration for a particular response.
 270 type ResponseParameters struct {
 271         // Desired payload sizes in responses from the server.
 272         // If response_type is COMPRESSABLE, this denotes the size before compression.
 273         Size int32 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
 274         // Desired interval between consecutive responses in the response stream in
 275         // microseconds.
 276         IntervalUs int32 `protobuf:"varint,2,opt,name=interval_us,json=intervalUs" json:"interval_us,omitempty"`
 277 }
 278
 279 func (m *ResponseParameters) Reset()                    { *m = ResponseParameters{} }
 280 func (m *ResponseParameters) String() string            { return proto.CompactTextString(m) }
 281 func (*ResponseParameters) ProtoMessage()               {}
 282 func (*ResponseParameters) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
 283
 284 func (m *ResponseParameters) GetSize() int32 {
 285         if m != nil {
 286                 return m.Size
 287         }
 288         return 0
 289 }
 290
 291 func (m *ResponseParameters) GetIntervalUs() int32 {
 292         if m != nil {
 293                 return m.IntervalUs
 294         }
 295         return 0
 296 }
 297
 298 // Server-streaming request.
 299 type StreamingOutputCallRequest struct {
 300         // Desired payload type in the response from the server.
 301         // If response_type is RANDOM, the payload from each response in the stream
 302         // might be of different types. This is to simulate a mixed type of payload
 303         // stream.
 304         ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,json=responseType,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
 305         // Configuration for each expected response message.
 306         ResponseParameters []*ResponseParameters `protobuf:"bytes,2,rep,name=response_parameters,json=responseParameters" json:"response_parameters,omitempty"`
 307         // Optional input payload sent along with the request.
 308         Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
 309         // Compression algorithm to be used by the server for the response (stream)
 310         ResponseCompression CompressionType `protobuf:"varint,6,opt,name=response_compression,json=responseCompression,enum=grpc.testing.CompressionType" json:"response_compression,omitempty"`
 311         // Whether server should return a given status
 312         ResponseStatus *EchoStatus `protobuf:"bytes,7,opt,name=response_status,json=responseStatus" json:"response_status,omitempty"`
 313 }
 314
 315 func (m *StreamingOutputCallRequest) Reset()                    { *m = StreamingOutputCallRequest{} }
 316 func (m *StreamingOutputCallRequest) String() string            { return proto.CompactTextString(m) }
 317 func (*StreamingOutputCallRequest) ProtoMessage()               {}
 318 func (*StreamingOutputCallRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
 319
 320 func (m *StreamingOutputCallRequest) GetResponseType() PayloadType {
 321         if m != nil {
 322                 return m.ResponseType
 323         }
 324         return PayloadType_COMPRESSABLE
 325 }
 326
 327 func (m *StreamingOutputCallRequest) GetResponseParameters() []*ResponseParameters {
 328         if m != nil {
 329                 return m.ResponseParameters
 330         }
 331         return nil
 332 }
 333
 334 func (m *StreamingOutputCallRequest) GetPayload() *Payload {
 335         if m != nil {
 336                 return m.Payload
 337         }
 338         return nil
 339 }
 340
 341 func (m *StreamingOutputCallRequest) GetResponseCompression() CompressionType {
 342         if m != nil {
 343                 return m.ResponseCompression
 344         }
 345         return CompressionType_NONE
 346 }
 347
 348 func (m *StreamingOutputCallRequest) GetResponseStatus() *EchoStatus {
 349         if m != nil {
 350                 return m.ResponseStatus
 351         }
 352         return nil
 353 }
 354
 355 // Server-streaming response, as configured by the request and parameters.
 356 type StreamingOutputCallResponse struct {
 357         // Payload to increase response size.
 358         Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
 359 }
 360
 361 func (m *StreamingOutputCallResponse) Reset()                    { *m = StreamingOutputCallResponse{} }
 362 func (m *StreamingOutputCallResponse) String() string            { return proto.CompactTextString(m) }
 363 func (*StreamingOutputCallResponse) ProtoMessage()               {}
 364 func (*StreamingOutputCallResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
 365
 366 func (m *StreamingOutputCallResponse) GetPayload() *Payload {
 367         if m != nil {
 368                 return m.Payload
 369         }
 370         return nil
 371 }
 372
 373 // For reconnect interop test only.
 374 // Client tells server what reconnection parameters it used.
 375 type ReconnectParams struct {
 376         MaxReconnectBackoffMs int32 `protobuf:"varint,1,opt,name=max_reconnect_backoff_ms,json=maxReconnectBackoffMs" json:"max_reconnect_backoff_ms,omitempty"`
 377 }
 378
 379 func (m *ReconnectParams) Reset()                    { *m = ReconnectParams{} }
 380 func (m *ReconnectParams) String() string            { return proto.CompactTextString(m) }
 381 func (*ReconnectParams) ProtoMessage()               {}
 382 func (*ReconnectParams) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} }
 383
 384 func (m *ReconnectParams) GetMaxReconnectBackoffMs() int32 {
 385         if m != nil {
 386                 return m.MaxReconnectBackoffMs
 387         }
 388         return 0
 389 }
 390
 391 // For reconnect interop test only.
 392 // Server tells client whether its reconnects are following the spec and the
 393 // reconnect backoffs it saw.
 394 type ReconnectInfo struct {
 395         Passed    bool    `protobuf:"varint,1,opt,name=passed" json:"passed,omitempty"`
 396         BackoffMs []int32 `protobuf:"varint,2,rep,packed,name=backoff_ms,json=backoffMs" json:"backoff_ms,omitempty"`
 397 }
 398
 399 func (m *ReconnectInfo) Reset()                    { *m = ReconnectInfo{} }
 400 func (m *ReconnectInfo) String() string            { return proto.CompactTextString(m) }
 401 func (*ReconnectInfo) ProtoMessage()               {}
 402 func (*ReconnectInfo) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} }
 403
 404 func (m *ReconnectInfo) GetPassed() bool {
 405         if m != nil {
 406                 return m.Passed
 407         }
 408         return false
 409 }
 410
 411 func (m *ReconnectInfo) GetBackoffMs() []int32 {
 412         if m != nil {
 413                 return m.BackoffMs
 414         }
 415         return nil
 416 }
 417
 418 func init() {
 419         proto.RegisterType((*Payload)(nil), "grpc.testing.Payload")
 420         proto.RegisterType((*EchoStatus)(nil), "grpc.testing.EchoStatus")
 421         proto.RegisterType((*SimpleRequest)(nil), "grpc.testing.SimpleRequest")
 422         proto.RegisterType((*SimpleResponse)(nil), "grpc.testing.SimpleResponse")
 423         proto.RegisterType((*StreamingInputCallRequest)(nil), "grpc.testing.StreamingInputCallRequest")
 424         proto.RegisterType((*StreamingInputCallResponse)(nil), "grpc.testing.StreamingInputCallResponse")
 425         proto.RegisterType((*ResponseParameters)(nil), "grpc.testing.ResponseParameters")
 426         proto.RegisterType((*StreamingOutputCallRequest)(nil), "grpc.testing.StreamingOutputCallRequest")
 427         proto.RegisterType((*StreamingOutputCallResponse)(nil), "grpc.testing.StreamingOutputCallResponse")
 428         proto.RegisterType((*ReconnectParams)(nil), "grpc.testing.ReconnectParams")
 429         proto.RegisterType((*ReconnectInfo)(nil), "grpc.testing.ReconnectInfo")
 430         proto.RegisterEnum("grpc.testing.PayloadType", PayloadType_name, PayloadType_value)
 431         proto.RegisterEnum("grpc.testing.CompressionType", CompressionType_name, CompressionType_value)
 432 }
 433
 434 func init() { proto.RegisterFile("messages.proto", fileDescriptor1) }
 435
 436 var fileDescriptor1 = []byte{
 437         // 652 bytes of a gzipped FileDescriptorProto
 438         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0x4d, 0x6f, 0xd3, 0x40,
 439         0x10, 0xc5, 0xf9, 0xee, 0x24, 0x4d, 0xa3, 0x85, 0x82, 0x5b, 0x54, 0x11, 0x99, 0x4b, 0x54, 0x89,
 440         0x20, 0x05, 0x09, 0x24, 0x0e, 0xa0, 0xb4, 0x4d, 0x51, 0x50, 0x9a, 0x84, 0x75, 0x7b, 0xe1, 0x62,
 441         0x6d, 0x9c, 0x8d, 0x6b, 0x11, 0x7b, 0x8d, 0x77, 0x8d, 0x9a, 0x1e, 0xb8, 0xf3, 0x83, 0xb9, 0xa3,
 442         0x5d, 0x7f, 0xc4, 0x69, 0x7b, 0x68, 0xe1, 0xc2, 0x6d, 0xf7, 0xed, 0x9b, 0x97, 0x79, 0x33, 0xcf,
 443         0x0a, 0x34, 0x3d, 0xca, 0x39, 0x71, 0x28, 0xef, 0x06, 0x21, 0x13, 0x0c, 0x35, 0x9c, 0x30, 0xb0,
 444         0xbb, 0x82, 0x72, 0xe1, 0xfa, 0x8e, 0x31, 0x82, 0xea, 0x94, 0xac, 0x96, 0x8c, 0xcc, 0xd1, 0x2b,
 445         0x28, 0x89, 0x55, 0x40, 0x75, 0xad, 0xad, 0x75, 0x9a, 0xbd, 0xbd, 0x6e, 0x9e, 0xd7, 0x4d, 0x48,
 446         0xe7, 0xab, 0x80, 0x62, 0x45, 0x43, 0x08, 0x4a, 0x33, 0x36, 0x5f, 0xe9, 0x85, 0xb6, 0xd6, 0x69,
 447         0x60, 0x75, 0x36, 0xde, 0x03, 0x0c, 0xec, 0x4b, 0x66, 0x0a, 0x22, 0x22, 0x2e, 0x19, 0x36, 0x9b,
 448         0xc7, 0x82, 0x65, 0xac, 0xce, 0x48, 0x87, 0x6a, 0xd2, 0x8f, 0x2a, 0xdc, 0xc2, 0xe9, 0xd5, 0xf8,
 449         0x55, 0x84, 0x6d, 0xd3, 0xf5, 0x82, 0x25, 0xc5, 0xf4, 0x7b, 0x44, 0xb9, 0x40, 0x1f, 0x60, 0x3b,
 450         0xa4, 0x3c, 0x60, 0x3e, 0xa7, 0xd6, 0xfd, 0x3a, 0x6b, 0xa4, 0x7c, 0x79, 0x43, 0x2f, 0x73, 0xf5,
 451         0xdc, 0xbd, 0x8e, 0x7f, 0xb1, 0xbc, 0x26, 0x99, 0xee, 0x35, 0x45, 0xaf, 0xa1, 0x1a, 0xc4, 0x0a,
 452         0x7a, 0xb1, 0xad, 0x75, 0xea, 0xbd, 0xdd, 0x3b, 0xe5, 0x71, 0xca, 0x92, 0xaa, 0x0b, 0x77, 0xb9,
 453         0xb4, 0x22, 0x4e, 0x43, 0x9f, 0x78, 0x54, 0x2f, 0xb5, 0xb5, 0x4e, 0x0d, 0x37, 0x24, 0x78, 0x91,
 454         0x60, 0xa8, 0x03, 0x2d, 0x45, 0x62, 0x24, 0x12, 0x97, 0x16, 0xb7, 0x59, 0x40, 0xf5, 0xb2, 0xe2,
 455         0x35, 0x25, 0x3e, 0x91, 0xb0, 0x29, 0x51, 0x34, 0x85, 0x27, 0x59, 0x93, 0x36, 0xf3, 0x82, 0x90,
 456         0x72, 0xee, 0x32, 0x5f, 0xaf, 0x28, 0xaf, 0x07, 0x9b, 0xcd, 0x1c, 0xaf, 0x09, 0xca, 0xef, 0xe3,
 457         0xb4, 0x34, 0xf7, 0x80, 0xfa, 0xb0, 0xb3, 0xb6, 0xad, 0x36, 0xa1, 0x57, 0x95, 0x33, 0x7d, 0x53,
 458         0x6c, 0xbd, 0x29, 0xdc, 0xcc, 0x46, 0xa2, 0xee, 0xc6, 0x4f, 0x68, 0xa6, 0xab, 0x88, 0xf1, 0xfc,
 459         0x98, 0xb4, 0x7b, 0x8d, 0x69, 0x1f, 0x6a, 0xd9, 0x84, 0xe2, 0x4d, 0x67, 0x77, 0xf4, 0x02, 0xea,
 460         0xf9, 0xc1, 0x14, 0xd5, 0x33, 0xb0, 0x6c, 0x28, 0xc6, 0x08, 0xf6, 0x4c, 0x11, 0x52, 0xe2, 0xb9,
 461         0xbe, 0x33, 0xf4, 0x83, 0x48, 0x1c, 0x93, 0xe5, 0x32, 0x8d, 0xc5, 0x43, 0x5b, 0x31, 0xce, 0x61,
 462         0xff, 0x2e, 0xb5, 0xc4, 0xd9, 0x5b, 0x78, 0x46, 0x1c, 0x27, 0xa4, 0x0e, 0x11, 0x74, 0x6e, 0x25,
 463         0x35, 0x71, 0x5e, 0xe2, 0xe0, 0xee, 0xae, 0x9f, 0x13, 0x69, 0x19, 0x1c, 0x63, 0x08, 0x28, 0xd5,
 464         0x98, 0x92, 0x90, 0x78, 0x54, 0xd0, 0x50, 0x65, 0x3e, 0x57, 0xaa, 0xce, 0xd2, 0xae, 0xeb, 0x0b,
 465         0x1a, 0xfe, 0x20, 0x32, 0x35, 0x49, 0x0a, 0x21, 0x85, 0x2e, 0xb8, 0xf1, 0xbb, 0x90, 0xeb, 0x70,
 466         0x12, 0x89, 0x1b, 0x86, 0xff, 0xf5, 0x3b, 0xf8, 0x02, 0x59, 0x4e, 0xac, 0x20, 0x6b, 0x55, 0x2f,
 467         0xb4, 0x8b, 0x9d, 0x7a, 0xaf, 0xbd, 0xa9, 0x72, 0xdb, 0x12, 0x46, 0xe1, 0x6d, 0x9b, 0x0f, 0xfe,
 468         0x6a, 0xfe, 0xcb, 0x98, 0x8f, 0xe1, 0xf9, 0x9d, 0x63, 0xff, 0xcb, 0xcc, 0x1b, 0x9f, 0x61, 0x07,
 469         0x53, 0x9b, 0xf9, 0x3e, 0xb5, 0x85, 0x1a, 0x16, 0x47, 0xef, 0x40, 0xf7, 0xc8, 0x95, 0x15, 0xa6,
 470         0xb0, 0x35, 0x23, 0xf6, 0x37, 0xb6, 0x58, 0x58, 0x1e, 0x4f, 0xe3, 0xe5, 0x91, 0xab, 0xac, 0xea,
 471         0x28, 0x7e, 0x3d, 0xe3, 0xc6, 0x29, 0x6c, 0x67, 0xe8, 0xd0, 0x5f, 0x30, 0xf4, 0x14, 0x2a, 0x01,
 472         0xe1, 0x9c, 0xc6, 0xcd, 0xd4, 0x70, 0x72, 0x43, 0x07, 0x00, 0x39, 0x4d, 0xb9, 0xd4, 0x32, 0xde,
 473         0x9a, 0xa5, 0x3a, 0x87, 0x1f, 0xa1, 0x9e, 0x4b, 0x06, 0x6a, 0x41, 0xe3, 0x78, 0x72, 0x36, 0xc5,
 474         0x03, 0xd3, 0xec, 0x1f, 0x8d, 0x06, 0xad, 0x47, 0x08, 0x41, 0xf3, 0x62, 0xbc, 0x81, 0x69, 0x08,
 475         0xa0, 0x82, 0xfb, 0xe3, 0x93, 0xc9, 0x59, 0xab, 0x70, 0xd8, 0x83, 0x9d, 0x1b, 0xfb, 0x40, 0x35,
 476         0x28, 0x8d, 0x27, 0x63, 0x59, 0x5c, 0x83, 0xd2, 0xa7, 0xaf, 0xc3, 0x69, 0x4b, 0x43, 0x75, 0xa8,
 477         0x9e, 0x0c, 0x4e, 0x47, 0xfd, 0xf3, 0x41, 0xab, 0x30, 0xab, 0xa8, 0xbf, 0x9a, 0x37, 0x7f, 0x02,
 478         0x00, 0x00, 0xff, 0xff, 0xc2, 0x6a, 0xce, 0x1e, 0x7c, 0x06, 0x00, 0x00,
 479 }