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

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: control.proto
   3
   4 /*
   5 Package grpc_testing is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         control.proto
   9         messages.proto
  10         payloads.proto
  11         services.proto
  12         stats.proto
  13
  14 It has these top-level messages:
  15         PoissonParams
  16         UniformParams
  17         DeterministicParams
  18         ParetoParams
  19         ClosedLoopParams
  20         LoadParams
  21         SecurityParams
  22         ClientConfig
  23         ClientStatus
  24         Mark
  25         ClientArgs
  26         ServerConfig
  27         ServerArgs
  28         ServerStatus
  29         CoreRequest
  30         CoreResponse
  31         Void
  32         Scenario
  33         Scenarios
  34         Payload
  35         EchoStatus
  36         SimpleRequest
  37         SimpleResponse
  38         StreamingInputCallRequest
  39         StreamingInputCallResponse
  40         ResponseParameters
  41         StreamingOutputCallRequest
  42         StreamingOutputCallResponse
  43         ReconnectParams
  44         ReconnectInfo
  45         ByteBufferParams
  46         SimpleProtoParams
  47         ComplexProtoParams
  48         PayloadConfig
  49         ServerStats
  50         HistogramParams
  51         HistogramData
  52         ClientStats
  53 */
  54 package grpc_testing
  55
  56 import proto "github.com/golang/protobuf/proto"
  57 import fmt "fmt"
  58 import math "math"
  59
  60 // Reference imports to suppress errors if they are not otherwise used.
  61 var _ = proto.Marshal
  62 var _ = fmt.Errorf
  63 var _ = math.Inf
  64
  65 // This is a compile-time assertion to ensure that this generated file
  66 // is compatible with the proto package it is being compiled against.
  67 // A compilation error at this line likely means your copy of the
  68 // proto package needs to be updated.
  69 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  70
  71 type ClientType int32
  72
  73 const (
  74         ClientType_SYNC_CLIENT  ClientType = 0
  75         ClientType_ASYNC_CLIENT ClientType = 1
  76 )
  77
  78 var ClientType_name = map[int32]string{
  79         0: "SYNC_CLIENT",
  80         1: "ASYNC_CLIENT",
  81 }
  82 var ClientType_value = map[string]int32{
  83         "SYNC_CLIENT":  0,
  84         "ASYNC_CLIENT": 1,
  85 }
  86
  87 func (x ClientType) String() string {
  88         return proto.EnumName(ClientType_name, int32(x))
  89 }
  90 func (ClientType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  91
  92 type ServerType int32
  93
  94 const (
  95         ServerType_SYNC_SERVER          ServerType = 0
  96         ServerType_ASYNC_SERVER         ServerType = 1
  97         ServerType_ASYNC_GENERIC_SERVER ServerType = 2
  98 )
  99
 100 var ServerType_name = map[int32]string{
 101         0: "SYNC_SERVER",
 102         1: "ASYNC_SERVER",
 103         2: "ASYNC_GENERIC_SERVER",
 104 }
 105 var ServerType_value = map[string]int32{
 106         "SYNC_SERVER":          0,
 107         "ASYNC_SERVER":         1,
 108         "ASYNC_GENERIC_SERVER": 2,
 109 }
 110
 111 func (x ServerType) String() string {
 112         return proto.EnumName(ServerType_name, int32(x))
 113 }
 114 func (ServerType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 115
 116 type RpcType int32
 117
 118 const (
 119         RpcType_UNARY     RpcType = 0
 120         RpcType_STREAMING RpcType = 1
 121 )
 122
 123 var RpcType_name = map[int32]string{
 124         0: "UNARY",
 125         1: "STREAMING",
 126 }
 127 var RpcType_value = map[string]int32{
 128         "UNARY":     0,
 129         "STREAMING": 1,
 130 }
 131
 132 func (x RpcType) String() string {
 133         return proto.EnumName(RpcType_name, int32(x))
 134 }
 135 func (RpcType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 136
 137 // Parameters of poisson process distribution, which is a good representation
 138 // of activity coming in from independent identical stationary sources.
 139 type PoissonParams struct {
 140         // The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
 141         OfferedLoad float64 `protobuf:"fixed64,1,opt,name=offered_load,json=offeredLoad" json:"offered_load,omitempty"`
 142 }
 143
 144 func (m *PoissonParams) Reset()                    { *m = PoissonParams{} }
 145 func (m *PoissonParams) String() string            { return proto.CompactTextString(m) }
 146 func (*PoissonParams) ProtoMessage()               {}
 147 func (*PoissonParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 148
 149 func (m *PoissonParams) GetOfferedLoad() float64 {
 150         if m != nil {
 151                 return m.OfferedLoad
 152         }
 153         return 0
 154 }
 155
 156 type UniformParams struct {
 157         InterarrivalLo float64 `protobuf:"fixed64,1,opt,name=interarrival_lo,json=interarrivalLo" json:"interarrival_lo,omitempty"`
 158         InterarrivalHi float64 `protobuf:"fixed64,2,opt,name=interarrival_hi,json=interarrivalHi" json:"interarrival_hi,omitempty"`
 159 }
 160
 161 func (m *UniformParams) Reset()                    { *m = UniformParams{} }
 162 func (m *UniformParams) String() string            { return proto.CompactTextString(m) }
 163 func (*UniformParams) ProtoMessage()               {}
 164 func (*UniformParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 165
 166 func (m *UniformParams) GetInterarrivalLo() float64 {
 167         if m != nil {
 168                 return m.InterarrivalLo
 169         }
 170         return 0
 171 }
 172
 173 func (m *UniformParams) GetInterarrivalHi() float64 {
 174         if m != nil {
 175                 return m.InterarrivalHi
 176         }
 177         return 0
 178 }
 179
 180 type DeterministicParams struct {
 181         OfferedLoad float64 `protobuf:"fixed64,1,opt,name=offered_load,json=offeredLoad" json:"offered_load,omitempty"`
 182 }
 183
 184 func (m *DeterministicParams) Reset()                    { *m = DeterministicParams{} }
 185 func (m *DeterministicParams) String() string            { return proto.CompactTextString(m) }
 186 func (*DeterministicParams) ProtoMessage()               {}
 187 func (*DeterministicParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 188
 189 func (m *DeterministicParams) GetOfferedLoad() float64 {
 190         if m != nil {
 191                 return m.OfferedLoad
 192         }
 193         return 0
 194 }
 195
 196 type ParetoParams struct {
 197         InterarrivalBase float64 `protobuf:"fixed64,1,opt,name=interarrival_base,json=interarrivalBase" json:"interarrival_base,omitempty"`
 198         Alpha            float64 `protobuf:"fixed64,2,opt,name=alpha" json:"alpha,omitempty"`
 199 }
 200
 201 func (m *ParetoParams) Reset()                    { *m = ParetoParams{} }
 202 func (m *ParetoParams) String() string            { return proto.CompactTextString(m) }
 203 func (*ParetoParams) ProtoMessage()               {}
 204 func (*ParetoParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 205
 206 func (m *ParetoParams) GetInterarrivalBase() float64 {
 207         if m != nil {
 208                 return m.InterarrivalBase
 209         }
 210         return 0
 211 }
 212
 213 func (m *ParetoParams) GetAlpha() float64 {
 214         if m != nil {
 215                 return m.Alpha
 216         }
 217         return 0
 218 }
 219
 220 // Once an RPC finishes, immediately start a new one.
 221 // No configuration parameters needed.
 222 type ClosedLoopParams struct {
 223 }
 224
 225 func (m *ClosedLoopParams) Reset()                    { *m = ClosedLoopParams{} }
 226 func (m *ClosedLoopParams) String() string            { return proto.CompactTextString(m) }
 227 func (*ClosedLoopParams) ProtoMessage()               {}
 228 func (*ClosedLoopParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 229
 230 type LoadParams struct {
 231         // Types that are valid to be assigned to Load:
 232         //      *LoadParams_ClosedLoop
 233         //      *LoadParams_Poisson
 234         //      *LoadParams_Uniform
 235         //      *LoadParams_Determ
 236         //      *LoadParams_Pareto
 237         Load isLoadParams_Load `protobuf_oneof:"load"`
 238 }
 239
 240 func (m *LoadParams) Reset()                    { *m = LoadParams{} }
 241 func (m *LoadParams) String() string            { return proto.CompactTextString(m) }
 242 func (*LoadParams) ProtoMessage()               {}
 243 func (*LoadParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 244
 245 type isLoadParams_Load interface {
 246         isLoadParams_Load()
 247 }
 248
 249 type LoadParams_ClosedLoop struct {
 250         ClosedLoop *ClosedLoopParams `protobuf:"bytes,1,opt,name=closed_loop,json=closedLoop,oneof"`
 251 }
 252 type LoadParams_Poisson struct {
 253         Poisson *PoissonParams `protobuf:"bytes,2,opt,name=poisson,oneof"`
 254 }
 255 type LoadParams_Uniform struct {
 256         Uniform *UniformParams `protobuf:"bytes,3,opt,name=uniform,oneof"`
 257 }
 258 type LoadParams_Determ struct {
 259         Determ *DeterministicParams `protobuf:"bytes,4,opt,name=determ,oneof"`
 260 }
 261 type LoadParams_Pareto struct {
 262         Pareto *ParetoParams `protobuf:"bytes,5,opt,name=pareto,oneof"`
 263 }
 264
 265 func (*LoadParams_ClosedLoop) isLoadParams_Load() {}
 266 func (*LoadParams_Poisson) isLoadParams_Load()    {}
 267 func (*LoadParams_Uniform) isLoadParams_Load()    {}
 268 func (*LoadParams_Determ) isLoadParams_Load()     {}
 269 func (*LoadParams_Pareto) isLoadParams_Load()     {}
 270
 271 func (m *LoadParams) GetLoad() isLoadParams_Load {
 272         if m != nil {
 273                 return m.Load
 274         }
 275         return nil
 276 }
 277
 278 func (m *LoadParams) GetClosedLoop() *ClosedLoopParams {
 279         if x, ok := m.GetLoad().(*LoadParams_ClosedLoop); ok {
 280                 return x.ClosedLoop
 281         }
 282         return nil
 283 }
 284
 285 func (m *LoadParams) GetPoisson() *PoissonParams {
 286         if x, ok := m.GetLoad().(*LoadParams_Poisson); ok {
 287                 return x.Poisson
 288         }
 289         return nil
 290 }
 291
 292 func (m *LoadParams) GetUniform() *UniformParams {
 293         if x, ok := m.GetLoad().(*LoadParams_Uniform); ok {
 294                 return x.Uniform
 295         }
 296         return nil
 297 }
 298
 299 func (m *LoadParams) GetDeterm() *DeterministicParams {
 300         if x, ok := m.GetLoad().(*LoadParams_Determ); ok {
 301                 return x.Determ
 302         }
 303         return nil
 304 }
 305
 306 func (m *LoadParams) GetPareto() *ParetoParams {
 307         if x, ok := m.GetLoad().(*LoadParams_Pareto); ok {
 308                 return x.Pareto
 309         }
 310         return nil
 311 }
 312
 313 // XXX_OneofFuncs is for the internal use of the proto package.
 314 func (*LoadParams) 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{}) {
 315         return _LoadParams_OneofMarshaler, _LoadParams_OneofUnmarshaler, _LoadParams_OneofSizer, []interface{}{
 316                 (*LoadParams_ClosedLoop)(nil),
 317                 (*LoadParams_Poisson)(nil),
 318                 (*LoadParams_Uniform)(nil),
 319                 (*LoadParams_Determ)(nil),
 320                 (*LoadParams_Pareto)(nil),
 321         }
 322 }
 323
 324 func _LoadParams_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 325         m := msg.(*LoadParams)
 326         // load
 327         switch x := m.Load.(type) {
 328         case *LoadParams_ClosedLoop:
 329                 b.EncodeVarint(1<<3 | proto.WireBytes)
 330                 if err := b.EncodeMessage(x.ClosedLoop); err != nil {
 331                         return err
 332                 }
 333         case *LoadParams_Poisson:
 334                 b.EncodeVarint(2<<3 | proto.WireBytes)
 335                 if err := b.EncodeMessage(x.Poisson); err != nil {
 336                         return err
 337                 }
 338         case *LoadParams_Uniform:
 339                 b.EncodeVarint(3<<3 | proto.WireBytes)
 340                 if err := b.EncodeMessage(x.Uniform); err != nil {
 341                         return err
 342                 }
 343         case *LoadParams_Determ:
 344                 b.EncodeVarint(4<<3 | proto.WireBytes)
 345                 if err := b.EncodeMessage(x.Determ); err != nil {
 346                         return err
 347                 }
 348         case *LoadParams_Pareto:
 349                 b.EncodeVarint(5<<3 | proto.WireBytes)
 350                 if err := b.EncodeMessage(x.Pareto); err != nil {
 351                         return err
 352                 }
 353         case nil:
 354         default:
 355                 return fmt.Errorf("LoadParams.Load has unexpected type %T", x)
 356         }
 357         return nil
 358 }
 359
 360 func _LoadParams_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 361         m := msg.(*LoadParams)
 362         switch tag {
 363         case 1: // load.closed_loop
 364                 if wire != proto.WireBytes {
 365                         return true, proto.ErrInternalBadWireType
 366                 }
 367                 msg := new(ClosedLoopParams)
 368                 err := b.DecodeMessage(msg)
 369                 m.Load = &LoadParams_ClosedLoop{msg}
 370                 return true, err
 371         case 2: // load.poisson
 372                 if wire != proto.WireBytes {
 373                         return true, proto.ErrInternalBadWireType
 374                 }
 375                 msg := new(PoissonParams)
 376                 err := b.DecodeMessage(msg)
 377                 m.Load = &LoadParams_Poisson{msg}
 378                 return true, err
 379         case 3: // load.uniform
 380                 if wire != proto.WireBytes {
 381                         return true, proto.ErrInternalBadWireType
 382                 }
 383                 msg := new(UniformParams)
 384                 err := b.DecodeMessage(msg)
 385                 m.Load = &LoadParams_Uniform{msg}
 386                 return true, err
 387         case 4: // load.determ
 388                 if wire != proto.WireBytes {
 389                         return true, proto.ErrInternalBadWireType
 390                 }
 391                 msg := new(DeterministicParams)
 392                 err := b.DecodeMessage(msg)
 393                 m.Load = &LoadParams_Determ{msg}
 394                 return true, err
 395         case 5: // load.pareto
 396                 if wire != proto.WireBytes {
 397                         return true, proto.ErrInternalBadWireType
 398                 }
 399                 msg := new(ParetoParams)
 400                 err := b.DecodeMessage(msg)
 401                 m.Load = &LoadParams_Pareto{msg}
 402                 return true, err
 403         default:
 404                 return false, nil
 405         }
 406 }
 407
 408 func _LoadParams_OneofSizer(msg proto.Message) (n int) {
 409         m := msg.(*LoadParams)
 410         // load
 411         switch x := m.Load.(type) {
 412         case *LoadParams_ClosedLoop:
 413                 s := proto.Size(x.ClosedLoop)
 414                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 415                 n += proto.SizeVarint(uint64(s))
 416                 n += s
 417         case *LoadParams_Poisson:
 418                 s := proto.Size(x.Poisson)
 419                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 420                 n += proto.SizeVarint(uint64(s))
 421                 n += s
 422         case *LoadParams_Uniform:
 423                 s := proto.Size(x.Uniform)
 424                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 425                 n += proto.SizeVarint(uint64(s))
 426                 n += s
 427         case *LoadParams_Determ:
 428                 s := proto.Size(x.Determ)
 429                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 430                 n += proto.SizeVarint(uint64(s))
 431                 n += s
 432         case *LoadParams_Pareto:
 433                 s := proto.Size(x.Pareto)
 434                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 435                 n += proto.SizeVarint(uint64(s))
 436                 n += s
 437         case nil:
 438         default:
 439                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 440         }
 441         return n
 442 }
 443
 444 // presence of SecurityParams implies use of TLS
 445 type SecurityParams struct {
 446         UseTestCa          bool   `protobuf:"varint,1,opt,name=use_test_ca,json=useTestCa" json:"use_test_ca,omitempty"`
 447         ServerHostOverride string `protobuf:"bytes,2,opt,name=server_host_override,json=serverHostOverride" json:"server_host_override,omitempty"`
 448 }
 449
 450 func (m *SecurityParams) Reset()                    { *m = SecurityParams{} }
 451 func (m *SecurityParams) String() string            { return proto.CompactTextString(m) }
 452 func (*SecurityParams) ProtoMessage()               {}
 453 func (*SecurityParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 454
 455 func (m *SecurityParams) GetUseTestCa() bool {
 456         if m != nil {
 457                 return m.UseTestCa
 458         }
 459         return false
 460 }
 461
 462 func (m *SecurityParams) GetServerHostOverride() string {
 463         if m != nil {
 464                 return m.ServerHostOverride
 465         }
 466         return ""
 467 }
 468
 469 type ClientConfig struct {
 470         // List of targets to connect to. At least one target needs to be specified.
 471         ServerTargets  []string        `protobuf:"bytes,1,rep,name=server_targets,json=serverTargets" json:"server_targets,omitempty"`
 472         ClientType     ClientType      `protobuf:"varint,2,opt,name=client_type,json=clientType,enum=grpc.testing.ClientType" json:"client_type,omitempty"`
 473         SecurityParams *SecurityParams `protobuf:"bytes,3,opt,name=security_params,json=securityParams" json:"security_params,omitempty"`
 474         // How many concurrent RPCs to start for each channel.
 475         // For synchronous client, use a separate thread for each outstanding RPC.
 476         OutstandingRpcsPerChannel int32 `protobuf:"varint,4,opt,name=outstanding_rpcs_per_channel,json=outstandingRpcsPerChannel" json:"outstanding_rpcs_per_channel,omitempty"`
 477         // Number of independent client channels to create.
 478         // i-th channel will connect to server_target[i % server_targets.size()]
 479         ClientChannels int32 `protobuf:"varint,5,opt,name=client_channels,json=clientChannels" json:"client_channels,omitempty"`
 480         // Only for async client. Number of threads to use to start/manage RPCs.
 481         AsyncClientThreads int32   `protobuf:"varint,7,opt,name=async_client_threads,json=asyncClientThreads" json:"async_client_threads,omitempty"`
 482         RpcType            RpcType `protobuf:"varint,8,opt,name=rpc_type,json=rpcType,enum=grpc.testing.RpcType" json:"rpc_type,omitempty"`
 483         // The requested load for the entire client (aggregated over all the threads).
 484         LoadParams      *LoadParams      `protobuf:"bytes,10,opt,name=load_params,json=loadParams" json:"load_params,omitempty"`
 485         PayloadConfig   *PayloadConfig   `protobuf:"bytes,11,opt,name=payload_config,json=payloadConfig" json:"payload_config,omitempty"`
 486         HistogramParams *HistogramParams `protobuf:"bytes,12,opt,name=histogram_params,json=histogramParams" json:"histogram_params,omitempty"`
 487         // Specify the cores we should run the client on, if desired
 488         CoreList  []int32 `protobuf:"varint,13,rep,packed,name=core_list,json=coreList" json:"core_list,omitempty"`
 489         CoreLimit int32   `protobuf:"varint,14,opt,name=core_limit,json=coreLimit" json:"core_limit,omitempty"`
 490 }
 491
 492 func (m *ClientConfig) Reset()                    { *m = ClientConfig{} }
 493 func (m *ClientConfig) String() string            { return proto.CompactTextString(m) }
 494 func (*ClientConfig) ProtoMessage()               {}
 495 func (*ClientConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 496
 497 func (m *ClientConfig) GetServerTargets() []string {
 498         if m != nil {
 499                 return m.ServerTargets
 500         }
 501         return nil
 502 }
 503
 504 func (m *ClientConfig) GetClientType() ClientType {
 505         if m != nil {
 506                 return m.ClientType
 507         }
 508         return ClientType_SYNC_CLIENT
 509 }
 510
 511 func (m *ClientConfig) GetSecurityParams() *SecurityParams {
 512         if m != nil {
 513                 return m.SecurityParams
 514         }
 515         return nil
 516 }
 517
 518 func (m *ClientConfig) GetOutstandingRpcsPerChannel() int32 {
 519         if m != nil {
 520                 return m.OutstandingRpcsPerChannel
 521         }
 522         return 0
 523 }
 524
 525 func (m *ClientConfig) GetClientChannels() int32 {
 526         if m != nil {
 527                 return m.ClientChannels
 528         }
 529         return 0
 530 }
 531
 532 func (m *ClientConfig) GetAsyncClientThreads() int32 {
 533         if m != nil {
 534                 return m.AsyncClientThreads
 535         }
 536         return 0
 537 }
 538
 539 func (m *ClientConfig) GetRpcType() RpcType {
 540         if m != nil {
 541                 return m.RpcType
 542         }
 543         return RpcType_UNARY
 544 }
 545
 546 func (m *ClientConfig) GetLoadParams() *LoadParams {
 547         if m != nil {
 548                 return m.LoadParams
 549         }
 550         return nil
 551 }
 552
 553 func (m *ClientConfig) GetPayloadConfig() *PayloadConfig {
 554         if m != nil {
 555                 return m.PayloadConfig
 556         }
 557         return nil
 558 }
 559
 560 func (m *ClientConfig) GetHistogramParams() *HistogramParams {
 561         if m != nil {
 562                 return m.HistogramParams
 563         }
 564         return nil
 565 }
 566
 567 func (m *ClientConfig) GetCoreList() []int32 {
 568         if m != nil {
 569                 return m.CoreList
 570         }
 571         return nil
 572 }
 573
 574 func (m *ClientConfig) GetCoreLimit() int32 {
 575         if m != nil {
 576                 return m.CoreLimit
 577         }
 578         return 0
 579 }
 580
 581 type ClientStatus struct {
 582         Stats *ClientStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
 583 }
 584
 585 func (m *ClientStatus) Reset()                    { *m = ClientStatus{} }
 586 func (m *ClientStatus) String() string            { return proto.CompactTextString(m) }
 587 func (*ClientStatus) ProtoMessage()               {}
 588 func (*ClientStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 589
 590 func (m *ClientStatus) GetStats() *ClientStats {
 591         if m != nil {
 592                 return m.Stats
 593         }
 594         return nil
 595 }
 596
 597 // Request current stats
 598 type Mark struct {
 599         // if true, the stats will be reset after taking their snapshot.
 600         Reset_ bool `protobuf:"varint,1,opt,name=reset" json:"reset,omitempty"`
 601 }
 602
 603 func (m *Mark) Reset()                    { *m = Mark{} }
 604 func (m *Mark) String() string            { return proto.CompactTextString(m) }
 605 func (*Mark) ProtoMessage()               {}
 606 func (*Mark) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 607
 608 func (m *Mark) GetReset_() bool {
 609         if m != nil {
 610                 return m.Reset_
 611         }
 612         return false
 613 }
 614
 615 type ClientArgs struct {
 616         // Types that are valid to be assigned to Argtype:
 617         //      *ClientArgs_Setup
 618         //      *ClientArgs_Mark
 619         Argtype isClientArgs_Argtype `protobuf_oneof:"argtype"`
 620 }
 621
 622 func (m *ClientArgs) Reset()                    { *m = ClientArgs{} }
 623 func (m *ClientArgs) String() string            { return proto.CompactTextString(m) }
 624 func (*ClientArgs) ProtoMessage()               {}
 625 func (*ClientArgs) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 626
 627 type isClientArgs_Argtype interface {
 628         isClientArgs_Argtype()
 629 }
 630
 631 type ClientArgs_Setup struct {
 632         Setup *ClientConfig `protobuf:"bytes,1,opt,name=setup,oneof"`
 633 }
 634 type ClientArgs_Mark struct {
 635         Mark *Mark `protobuf:"bytes,2,opt,name=mark,oneof"`
 636 }
 637
 638 func (*ClientArgs_Setup) isClientArgs_Argtype() {}
 639 func (*ClientArgs_Mark) isClientArgs_Argtype()  {}
 640
 641 func (m *ClientArgs) GetArgtype() isClientArgs_Argtype {
 642         if m != nil {
 643                 return m.Argtype
 644         }
 645         return nil
 646 }
 647
 648 func (m *ClientArgs) GetSetup() *ClientConfig {
 649         if x, ok := m.GetArgtype().(*ClientArgs_Setup); ok {
 650                 return x.Setup
 651         }
 652         return nil
 653 }
 654
 655 func (m *ClientArgs) GetMark() *Mark {
 656         if x, ok := m.GetArgtype().(*ClientArgs_Mark); ok {
 657                 return x.Mark
 658         }
 659         return nil
 660 }
 661
 662 // XXX_OneofFuncs is for the internal use of the proto package.
 663 func (*ClientArgs) 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{}) {
 664         return _ClientArgs_OneofMarshaler, _ClientArgs_OneofUnmarshaler, _ClientArgs_OneofSizer, []interface{}{
 665                 (*ClientArgs_Setup)(nil),
 666                 (*ClientArgs_Mark)(nil),
 667         }
 668 }
 669
 670 func _ClientArgs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 671         m := msg.(*ClientArgs)
 672         // argtype
 673         switch x := m.Argtype.(type) {
 674         case *ClientArgs_Setup:
 675                 b.EncodeVarint(1<<3 | proto.WireBytes)
 676                 if err := b.EncodeMessage(x.Setup); err != nil {
 677                         return err
 678                 }
 679         case *ClientArgs_Mark:
 680                 b.EncodeVarint(2<<3 | proto.WireBytes)
 681                 if err := b.EncodeMessage(x.Mark); err != nil {
 682                         return err
 683                 }
 684         case nil:
 685         default:
 686                 return fmt.Errorf("ClientArgs.Argtype has unexpected type %T", x)
 687         }
 688         return nil
 689 }
 690
 691 func _ClientArgs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 692         m := msg.(*ClientArgs)
 693         switch tag {
 694         case 1: // argtype.setup
 695                 if wire != proto.WireBytes {
 696                         return true, proto.ErrInternalBadWireType
 697                 }
 698                 msg := new(ClientConfig)
 699                 err := b.DecodeMessage(msg)
 700                 m.Argtype = &ClientArgs_Setup{msg}
 701                 return true, err
 702         case 2: // argtype.mark
 703                 if wire != proto.WireBytes {
 704                         return true, proto.ErrInternalBadWireType
 705                 }
 706                 msg := new(Mark)
 707                 err := b.DecodeMessage(msg)
 708                 m.Argtype = &ClientArgs_Mark{msg}
 709                 return true, err
 710         default:
 711                 return false, nil
 712         }
 713 }
 714
 715 func _ClientArgs_OneofSizer(msg proto.Message) (n int) {
 716         m := msg.(*ClientArgs)
 717         // argtype
 718         switch x := m.Argtype.(type) {
 719         case *ClientArgs_Setup:
 720                 s := proto.Size(x.Setup)
 721                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 722                 n += proto.SizeVarint(uint64(s))
 723                 n += s
 724         case *ClientArgs_Mark:
 725                 s := proto.Size(x.Mark)
 726                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 727                 n += proto.SizeVarint(uint64(s))
 728                 n += s
 729         case nil:
 730         default:
 731                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 732         }
 733         return n
 734 }
 735
 736 type ServerConfig struct {
 737         ServerType     ServerType      `protobuf:"varint,1,opt,name=server_type,json=serverType,enum=grpc.testing.ServerType" json:"server_type,omitempty"`
 738         SecurityParams *SecurityParams `protobuf:"bytes,2,opt,name=security_params,json=securityParams" json:"security_params,omitempty"`
 739         // Port on which to listen. Zero means pick unused port.
 740         Port int32 `protobuf:"varint,4,opt,name=port" json:"port,omitempty"`
 741         // Only for async server. Number of threads used to serve the requests.
 742         AsyncServerThreads int32 `protobuf:"varint,7,opt,name=async_server_threads,json=asyncServerThreads" json:"async_server_threads,omitempty"`
 743         // Specify the number of cores to limit server to, if desired
 744         CoreLimit int32 `protobuf:"varint,8,opt,name=core_limit,json=coreLimit" json:"core_limit,omitempty"`
 745         // payload config, used in generic server
 746         PayloadConfig *PayloadConfig `protobuf:"bytes,9,opt,name=payload_config,json=payloadConfig" json:"payload_config,omitempty"`
 747         // Specify the cores we should run the server on, if desired
 748         CoreList []int32 `protobuf:"varint,10,rep,packed,name=core_list,json=coreList" json:"core_list,omitempty"`
 749 }
 750
 751 func (m *ServerConfig) Reset()                    { *m = ServerConfig{} }
 752 func (m *ServerConfig) String() string            { return proto.CompactTextString(m) }
 753 func (*ServerConfig) ProtoMessage()               {}
 754 func (*ServerConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 755
 756 func (m *ServerConfig) GetServerType() ServerType {
 757         if m != nil {
 758                 return m.ServerType
 759         }
 760         return ServerType_SYNC_SERVER
 761 }
 762
 763 func (m *ServerConfig) GetSecurityParams() *SecurityParams {
 764         if m != nil {
 765                 return m.SecurityParams
 766         }
 767         return nil
 768 }
 769
 770 func (m *ServerConfig) GetPort() int32 {
 771         if m != nil {
 772                 return m.Port
 773         }
 774         return 0
 775 }
 776
 777 func (m *ServerConfig) GetAsyncServerThreads() int32 {
 778         if m != nil {
 779                 return m.AsyncServerThreads
 780         }
 781         return 0
 782 }
 783
 784 func (m *ServerConfig) GetCoreLimit() int32 {
 785         if m != nil {
 786                 return m.CoreLimit
 787         }
 788         return 0
 789 }
 790
 791 func (m *ServerConfig) GetPayloadConfig() *PayloadConfig {
 792         if m != nil {
 793                 return m.PayloadConfig
 794         }
 795         return nil
 796 }
 797
 798 func (m *ServerConfig) GetCoreList() []int32 {
 799         if m != nil {
 800                 return m.CoreList
 801         }
 802         return nil
 803 }
 804
 805 type ServerArgs struct {
 806         // Types that are valid to be assigned to Argtype:
 807         //      *ServerArgs_Setup
 808         //      *ServerArgs_Mark
 809         Argtype isServerArgs_Argtype `protobuf_oneof:"argtype"`
 810 }
 811
 812 func (m *ServerArgs) Reset()                    { *m = ServerArgs{} }
 813 func (m *ServerArgs) String() string            { return proto.CompactTextString(m) }
 814 func (*ServerArgs) ProtoMessage()               {}
 815 func (*ServerArgs) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 816
 817 type isServerArgs_Argtype interface {
 818         isServerArgs_Argtype()
 819 }
 820
 821 type ServerArgs_Setup struct {
 822         Setup *ServerConfig `protobuf:"bytes,1,opt,name=setup,oneof"`
 823 }
 824 type ServerArgs_Mark struct {
 825         Mark *Mark `protobuf:"bytes,2,opt,name=mark,oneof"`
 826 }
 827
 828 func (*ServerArgs_Setup) isServerArgs_Argtype() {}
 829 func (*ServerArgs_Mark) isServerArgs_Argtype()  {}
 830
 831 func (m *ServerArgs) GetArgtype() isServerArgs_Argtype {
 832         if m != nil {
 833                 return m.Argtype
 834         }
 835         return nil
 836 }
 837
 838 func (m *ServerArgs) GetSetup() *ServerConfig {
 839         if x, ok := m.GetArgtype().(*ServerArgs_Setup); ok {
 840                 return x.Setup
 841         }
 842         return nil
 843 }
 844
 845 func (m *ServerArgs) GetMark() *Mark {
 846         if x, ok := m.GetArgtype().(*ServerArgs_Mark); ok {
 847                 return x.Mark
 848         }
 849         return nil
 850 }
 851
 852 // XXX_OneofFuncs is for the internal use of the proto package.
 853 func (*ServerArgs) 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{}) {
 854         return _ServerArgs_OneofMarshaler, _ServerArgs_OneofUnmarshaler, _ServerArgs_OneofSizer, []interface{}{
 855                 (*ServerArgs_Setup)(nil),
 856                 (*ServerArgs_Mark)(nil),
 857         }
 858 }
 859
 860 func _ServerArgs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 861         m := msg.(*ServerArgs)
 862         // argtype
 863         switch x := m.Argtype.(type) {
 864         case *ServerArgs_Setup:
 865                 b.EncodeVarint(1<<3 | proto.WireBytes)
 866                 if err := b.EncodeMessage(x.Setup); err != nil {
 867                         return err
 868                 }
 869         case *ServerArgs_Mark:
 870                 b.EncodeVarint(2<<3 | proto.WireBytes)
 871                 if err := b.EncodeMessage(x.Mark); err != nil {
 872                         return err
 873                 }
 874         case nil:
 875         default:
 876                 return fmt.Errorf("ServerArgs.Argtype has unexpected type %T", x)
 877         }
 878         return nil
 879 }
 880
 881 func _ServerArgs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 882         m := msg.(*ServerArgs)
 883         switch tag {
 884         case 1: // argtype.setup
 885                 if wire != proto.WireBytes {
 886                         return true, proto.ErrInternalBadWireType
 887                 }
 888                 msg := new(ServerConfig)
 889                 err := b.DecodeMessage(msg)
 890                 m.Argtype = &ServerArgs_Setup{msg}
 891                 return true, err
 892         case 2: // argtype.mark
 893                 if wire != proto.WireBytes {
 894                         return true, proto.ErrInternalBadWireType
 895                 }
 896                 msg := new(Mark)
 897                 err := b.DecodeMessage(msg)
 898                 m.Argtype = &ServerArgs_Mark{msg}
 899                 return true, err
 900         default:
 901                 return false, nil
 902         }
 903 }
 904
 905 func _ServerArgs_OneofSizer(msg proto.Message) (n int) {
 906         m := msg.(*ServerArgs)
 907         // argtype
 908         switch x := m.Argtype.(type) {
 909         case *ServerArgs_Setup:
 910                 s := proto.Size(x.Setup)
 911                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 912                 n += proto.SizeVarint(uint64(s))
 913                 n += s
 914         case *ServerArgs_Mark:
 915                 s := proto.Size(x.Mark)
 916                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 917                 n += proto.SizeVarint(uint64(s))
 918                 n += s
 919         case nil:
 920         default:
 921                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 922         }
 923         return n
 924 }
 925
 926 type ServerStatus struct {
 927         Stats *ServerStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
 928         // the port bound by the server
 929         Port int32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
 930         // Number of cores available to the server
 931         Cores int32 `protobuf:"varint,3,opt,name=cores" json:"cores,omitempty"`
 932 }
 933
 934 func (m *ServerStatus) Reset()                    { *m = ServerStatus{} }
 935 func (m *ServerStatus) String() string            { return proto.CompactTextString(m) }
 936 func (*ServerStatus) ProtoMessage()               {}
 937 func (*ServerStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 938
 939 func (m *ServerStatus) GetStats() *ServerStats {
 940         if m != nil {
 941                 return m.Stats
 942         }
 943         return nil
 944 }
 945
 946 func (m *ServerStatus) GetPort() int32 {
 947         if m != nil {
 948                 return m.Port
 949         }
 950         return 0
 951 }
 952
 953 func (m *ServerStatus) GetCores() int32 {
 954         if m != nil {
 955                 return m.Cores
 956         }
 957         return 0
 958 }
 959
 960 type CoreRequest struct {
 961 }
 962
 963 func (m *CoreRequest) Reset()                    { *m = CoreRequest{} }
 964 func (m *CoreRequest) String() string            { return proto.CompactTextString(m) }
 965 func (*CoreRequest) ProtoMessage()               {}
 966 func (*CoreRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 967
 968 type CoreResponse struct {
 969         // Number of cores available on the server
 970         Cores int32 `protobuf:"varint,1,opt,name=cores" json:"cores,omitempty"`
 971 }
 972
 973 func (m *CoreResponse) Reset()                    { *m = CoreResponse{} }
 974 func (m *CoreResponse) String() string            { return proto.CompactTextString(m) }
 975 func (*CoreResponse) ProtoMessage()               {}
 976 func (*CoreResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 977
 978 func (m *CoreResponse) GetCores() int32 {
 979         if m != nil {
 980                 return m.Cores
 981         }
 982         return 0
 983 }
 984
 985 type Void struct {
 986 }
 987
 988 func (m *Void) Reset()                    { *m = Void{} }
 989 func (m *Void) String() string            { return proto.CompactTextString(m) }
 990 func (*Void) ProtoMessage()               {}
 991 func (*Void) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
 992
 993 // A single performance scenario: input to qps_json_driver
 994 type Scenario struct {
 995         // Human readable name for this scenario
 996         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 997         // Client configuration
 998         ClientConfig *ClientConfig `protobuf:"bytes,2,opt,name=client_config,json=clientConfig" json:"client_config,omitempty"`
 999         // Number of clients to start for the test
1000         NumClients int32 `protobuf:"varint,3,opt,name=num_clients,json=numClients" json:"num_clients,omitempty"`
1001         // Server configuration
1002         ServerConfig *ServerConfig `protobuf:"bytes,4,opt,name=server_config,json=serverConfig" json:"server_config,omitempty"`
1003         // Number of servers to start for the test
1004         NumServers int32 `protobuf:"varint,5,opt,name=num_servers,json=numServers" json:"num_servers,omitempty"`
1005         // Warmup period, in seconds
1006         WarmupSeconds int32 `protobuf:"varint,6,opt,name=warmup_seconds,json=warmupSeconds" json:"warmup_seconds,omitempty"`
1007         // Benchmark time, in seconds
1008         BenchmarkSeconds int32 `protobuf:"varint,7,opt,name=benchmark_seconds,json=benchmarkSeconds" json:"benchmark_seconds,omitempty"`
1009         // Number of workers to spawn locally (usually zero)
1010         SpawnLocalWorkerCount int32 `protobuf:"varint,8,opt,name=spawn_local_worker_count,json=spawnLocalWorkerCount" json:"spawn_local_worker_count,omitempty"`
1011 }
1012
1013 func (m *Scenario) Reset()                    { *m = Scenario{} }
1014 func (m *Scenario) String() string            { return proto.CompactTextString(m) }
1015 func (*Scenario) ProtoMessage()               {}
1016 func (*Scenario) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
1017
1018 func (m *Scenario) GetName() string {
1019         if m != nil {
1020                 return m.Name
1021         }
1022         return ""
1023 }
1024
1025 func (m *Scenario) GetClientConfig() *ClientConfig {
1026         if m != nil {
1027                 return m.ClientConfig
1028         }
1029         return nil
1030 }
1031
1032 func (m *Scenario) GetNumClients() int32 {
1033         if m != nil {
1034                 return m.NumClients
1035         }
1036         return 0
1037 }
1038
1039 func (m *Scenario) GetServerConfig() *ServerConfig {
1040         if m != nil {
1041                 return m.ServerConfig
1042         }
1043         return nil
1044 }
1045
1046 func (m *Scenario) GetNumServers() int32 {
1047         if m != nil {
1048                 return m.NumServers
1049         }
1050         return 0
1051 }
1052
1053 func (m *Scenario) GetWarmupSeconds() int32 {
1054         if m != nil {
1055                 return m.WarmupSeconds
1056         }
1057         return 0
1058 }
1059
1060 func (m *Scenario) GetBenchmarkSeconds() int32 {
1061         if m != nil {
1062                 return m.BenchmarkSeconds
1063         }
1064         return 0
1065 }
1066
1067 func (m *Scenario) GetSpawnLocalWorkerCount() int32 {
1068         if m != nil {
1069                 return m.SpawnLocalWorkerCount
1070         }
1071         return 0
1072 }
1073
1074 // A set of scenarios to be run with qps_json_driver
1075 type Scenarios struct {
1076         Scenarios []*Scenario `protobuf:"bytes,1,rep,name=scenarios" json:"scenarios,omitempty"`
1077 }
1078
1079 func (m *Scenarios) Reset()                    { *m = Scenarios{} }
1080 func (m *Scenarios) String() string            { return proto.CompactTextString(m) }
1081 func (*Scenarios) ProtoMessage()               {}
1082 func (*Scenarios) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
1083
1084 func (m *Scenarios) GetScenarios() []*Scenario {
1085         if m != nil {
1086                 return m.Scenarios
1087         }
1088         return nil
1089 }
1090
1091 func init() {
1092         proto.RegisterType((*PoissonParams)(nil), "grpc.testing.PoissonParams")
1093         proto.RegisterType((*UniformParams)(nil), "grpc.testing.UniformParams")
1094         proto.RegisterType((*DeterministicParams)(nil), "grpc.testing.DeterministicParams")
1095         proto.RegisterType((*ParetoParams)(nil), "grpc.testing.ParetoParams")
1096         proto.RegisterType((*ClosedLoopParams)(nil), "grpc.testing.ClosedLoopParams")
1097         proto.RegisterType((*LoadParams)(nil), "grpc.testing.LoadParams")
1098         proto.RegisterType((*SecurityParams)(nil), "grpc.testing.SecurityParams")
1099         proto.RegisterType((*ClientConfig)(nil), "grpc.testing.ClientConfig")
1100         proto.RegisterType((*ClientStatus)(nil), "grpc.testing.ClientStatus")
1101         proto.RegisterType((*Mark)(nil), "grpc.testing.Mark")
1102         proto.RegisterType((*ClientArgs)(nil), "grpc.testing.ClientArgs")
1103         proto.RegisterType((*ServerConfig)(nil), "grpc.testing.ServerConfig")
1104         proto.RegisterType((*ServerArgs)(nil), "grpc.testing.ServerArgs")
1105         proto.RegisterType((*ServerStatus)(nil), "grpc.testing.ServerStatus")
1106         proto.RegisterType((*CoreRequest)(nil), "grpc.testing.CoreRequest")
1107         proto.RegisterType((*CoreResponse)(nil), "grpc.testing.CoreResponse")
1108         proto.RegisterType((*Void)(nil), "grpc.testing.Void")
1109         proto.RegisterType((*Scenario)(nil), "grpc.testing.Scenario")
1110         proto.RegisterType((*Scenarios)(nil), "grpc.testing.Scenarios")
1111         proto.RegisterEnum("grpc.testing.ClientType", ClientType_name, ClientType_value)
1112         proto.RegisterEnum("grpc.testing.ServerType", ServerType_name, ServerType_value)
1113         proto.RegisterEnum("grpc.testing.RpcType", RpcType_name, RpcType_value)
1114 }
1115
1116 func init() { proto.RegisterFile("control.proto", fileDescriptor0) }
1117
1118 var fileDescriptor0 = []byte{
1119         // 1179 bytes of a gzipped FileDescriptorProto
1120         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x6f, 0x6f, 0xdb, 0xb6,
1121         0x13, 0xb6, 0x1d, 0xdb, 0xb1, 0x4e, 0xb6, 0xe3, 0x1f, 0x7f, 0xe9, 0xa0, 0xa6, 0x69, 0x97, 0x6a,
1122         0x1b, 0x16, 0x64, 0x40, 0x5a, 0x78, 0x05, 0xba, 0x62, 0x2f, 0x02, 0xc7, 0x33, 0xea, 0x00, 0x69,
1123         0x96, 0xd1, 0x69, 0x87, 0xbe, 0x12, 0x18, 0x99, 0xb1, 0x85, 0xc8, 0xa2, 0x46, 0x52, 0x09, 0xf2,
1124         0x15, 0xf6, 0x99, 0xf6, 0x39, 0xf6, 0x35, 0xf6, 0x15, 0x06, 0xfe, 0x91, 0x23, 0xb9, 0x06, 0x9a,
1125         0x6d, 0xef, 0xc4, 0xbb, 0xe7, 0xe1, 0x91, 0xf7, 0xdc, 0x1d, 0x05, 0x9d, 0x90, 0x25, 0x92, 0xb3,
1126         0xf8, 0x30, 0xe5, 0x4c, 0x32, 0xd4, 0x9e, 0xf1, 0x34, 0x3c, 0x94, 0x54, 0xc8, 0x28, 0x99, 0xed,
1127         0x74, 0x53, 0x72, 0x17, 0x33, 0x32, 0x15, 0xc6, 0xbb, 0xe3, 0x0a, 0x49, 0xa4, 0x5d, 0xf8, 0x7d,
1128         0xe8, 0x9c, 0xb3, 0x48, 0x08, 0x96, 0x9c, 0x13, 0x4e, 0x16, 0x02, 0x3d, 0x87, 0x36, 0xbb, 0xba,
1129         0xa2, 0x9c, 0x4e, 0x03, 0x45, 0xf2, 0xaa, 0x7b, 0xd5, 0xfd, 0x2a, 0x76, 0xad, 0xed, 0x94, 0x91,
1130         0xa9, 0x4f, 0xa0, 0xf3, 0x3e, 0x89, 0xae, 0x18, 0x5f, 0x58, 0xce, 0xb7, 0xb0, 0x15, 0x25, 0x92,
1131         0x72, 0xc2, 0x79, 0x74, 0x43, 0xe2, 0x20, 0x66, 0x96, 0xd6, 0x2d, 0x9a, 0x4f, 0xd9, 0x27, 0xc0,
1132         0x79, 0xe4, 0xd5, 0x3e, 0x05, 0x8e, 0x23, 0xff, 0x07, 0xf8, 0xff, 0x4f, 0x54, 0x52, 0xbe, 0x88,
1133         0x92, 0x48, 0xc8, 0x28, 0x7c, 0xf8, 0xe1, 0x7e, 0x81, 0xf6, 0x39, 0xe1, 0x54, 0x32, 0x4b, 0xf9,
1134         0x0e, 0xfe, 0x57, 0x0a, 0x79, 0x49, 0x04, 0xb5, 0xbc, 0x5e, 0xd1, 0x71, 0x4c, 0x04, 0x45, 0xdb,
1135         0xd0, 0x20, 0x71, 0x3a, 0x27, 0xf6, 0x54, 0x66, 0xe1, 0x23, 0xe8, 0x0d, 0x63, 0x26, 0x54, 0x00,
1136         0x96, 0x9a, 0x6d, 0xfd, 0x3f, 0x6a, 0x00, 0x2a, 0x9e, 0x8d, 0x32, 0x00, 0x37, 0xd4, 0x90, 0x20,
1137         0x66, 0x2c, 0xd5, 0xfb, 0xbb, 0xfd, 0x67, 0x87, 0x45, 0x1d, 0x0e, 0x57, 0xf7, 0x18, 0x57, 0x30,
1138         0x84, 0x4b, 0x1b, 0x7a, 0x0d, 0x9b, 0xa9, 0x51, 0x42, 0x47, 0x77, 0xfb, 0x4f, 0xca, 0xf4, 0x92,
1139         0x4c, 0xe3, 0x0a, 0xce, 0xd1, 0x8a, 0x98, 0x19, 0x39, 0xbc, 0x8d, 0x75, 0xc4, 0x92, 0x56, 0x8a,
1140         0x68, 0xd1, 0xe8, 0x47, 0x68, 0x4e, 0x75, 0x92, 0xbd, 0xba, 0xe6, 0x3d, 0x2f, 0xf3, 0xd6, 0x08,
1141         0x30, 0xae, 0x60, 0x4b, 0x41, 0xaf, 0xa0, 0x99, 0xea, 0x3c, 0x7b, 0x0d, 0x4d, 0xde, 0x59, 0x39,
1142         0x6d, 0x41, 0x03, 0xc5, 0x32, 0xd8, 0xe3, 0x26, 0xd4, 0x95, 0x70, 0xfe, 0x25, 0x74, 0x27, 0x34,
1143         0xcc, 0x78, 0x24, 0xef, 0x6c, 0x06, 0x9f, 0x81, 0x9b, 0x09, 0x1a, 0x28, 0x7e, 0x10, 0x12, 0x9d,
1144         0xc1, 0x16, 0x76, 0x32, 0x41, 0x2f, 0xa8, 0x90, 0x43, 0x82, 0x5e, 0xc2, 0xb6, 0xa0, 0xfc, 0x86,
1145         0xf2, 0x60, 0xce, 0x84, 0x0c, 0xd8, 0x0d, 0xe5, 0x3c, 0x9a, 0x52, 0x9d, 0x2b, 0x07, 0x23, 0xe3,
1146         0x1b, 0x33, 0x21, 0x7f, 0xb6, 0x1e, 0xff, 0xf7, 0x06, 0xb4, 0x87, 0x71, 0x44, 0x13, 0x39, 0x64,
1147         0xc9, 0x55, 0x34, 0x43, 0xdf, 0x40, 0xd7, 0x6e, 0x21, 0x09, 0x9f, 0x51, 0x29, 0xbc, 0xea, 0xde,
1148         0xc6, 0xbe, 0x83, 0x3b, 0xc6, 0x7a, 0x61, 0x8c, 0xe8, 0x8d, 0xd2, 0x52, 0xd1, 0x02, 0x79, 0x97,
1149         0x9a, 0x00, 0xdd, 0xbe, 0xb7, 0xaa, 0xa5, 0x02, 0x5c, 0xdc, 0xa5, 0x54, 0x69, 0x98, 0x7f, 0xa3,
1150         0x11, 0x6c, 0x09, 0x7b, 0xad, 0x20, 0xd5, 0xf7, 0xb2, 0x92, 0xec, 0x96, 0xe9, 0xe5, 0xbb, 0xe3,
1151         0xae, 0x28, 0xe7, 0xe2, 0x08, 0x76, 0x59, 0x26, 0x85, 0x24, 0xc9, 0x34, 0x4a, 0x66, 0x01, 0x4f,
1152         0x43, 0x11, 0xa4, 0x94, 0x07, 0xe1, 0x9c, 0x24, 0x09, 0x8d, 0xb5, 0x5c, 0x0d, 0xfc, 0xb8, 0x80,
1153         0xc1, 0x69, 0x28, 0xce, 0x29, 0x1f, 0x1a, 0x80, 0xea, 0x33, 0x7b, 0x05, 0x4b, 0x11, 0x5a, 0xa5,
1154         0x06, 0xee, 0x1a, 0xb3, 0xc5, 0x09, 0x95, 0x55, 0x22, 0xee, 0x92, 0x30, 0xc8, 0x6f, 0x3c, 0xe7,
1155         0x94, 0x4c, 0x85, 0xb7, 0xa9, 0xd1, 0x48, 0xfb, 0xec, 0x5d, 0x8d, 0x07, 0xbd, 0x84, 0x16, 0x4f,
1156         0x43, 0x93, 0x9a, 0x96, 0x4e, 0xcd, 0xa3, 0xf2, 0xdd, 0x70, 0x1a, 0xea, 0xbc, 0x6c, 0x72, 0xf3,
1157         0xa1, 0xf2, 0xa9, 0x34, 0xcf, 0x13, 0x02, 0x3a, 0x21, 0x2b, 0xf9, 0xbc, 0x6f, 0x25, 0x0c, 0xf1,
1158         0x7d, 0x5b, 0x1d, 0x43, 0x3e, 0xbc, 0x82, 0x50, 0x6b, 0xe8, 0xb9, 0x6b, 0x5b, 0xc3, 0x60, 0x8c,
1159         0xcc, 0xb8, 0x93, 0x16, 0x97, 0x68, 0x0c, 0xbd, 0x79, 0x24, 0x24, 0x9b, 0x71, 0xb2, 0xc8, 0xcf,
1160         0xd0, 0xd6, 0xbb, 0x3c, 0x2d, 0xef, 0x32, 0xce, 0x51, 0xf6, 0x20, 0x5b, 0xf3, 0xb2, 0x01, 0x3d,
1161         0x01, 0x27, 0x64, 0x9c, 0x06, 0x71, 0x24, 0xa4, 0xd7, 0xd9, 0xdb, 0xd8, 0x6f, 0xe0, 0x96, 0x32,
1162         0x9c, 0x46, 0x42, 0xa2, 0xa7, 0x00, 0xd6, 0xb9, 0x88, 0xa4, 0xd7, 0xd5, 0xf9, 0x73, 0x8c, 0x77,
1163         0x11, 0x49, 0xff, 0x28, 0xaf, 0xc5, 0x89, 0x24, 0x32, 0x13, 0xe8, 0x05, 0x34, 0xf4, 0x18, 0xb6,
1164         0xa3, 0xe2, 0xf1, 0xba, 0xf2, 0x52, 0x50, 0x81, 0x0d, 0xce, 0xdf, 0x85, 0xfa, 0x3b, 0xc2, 0xaf,
1165         0xd5, 0x88, 0xe2, 0x54, 0x50, 0x69, 0x3b, 0xc4, 0x2c, 0xfc, 0x0c, 0xc0, 0x70, 0x06, 0x7c, 0x26,
1166         0x50, 0x1f, 0x1a, 0x82, 0xca, 0x2c, 0x9f, 0x43, 0x3b, 0xeb, 0x36, 0x37, 0xd9, 0x19, 0x57, 0xb0,
1167         0x81, 0xa2, 0x7d, 0xa8, 0x2f, 0x08, 0xbf, 0xb6, 0xb3, 0x07, 0x95, 0x29, 0x2a, 0xf2, 0xb8, 0x82,
1168         0x35, 0xe2, 0xd8, 0x81, 0x4d, 0xc2, 0x67, 0xaa, 0x00, 0xfc, 0x3f, 0x6b, 0xd0, 0x9e, 0xe8, 0xe6,
1169         0xb1, 0xc9, 0x7e, 0x03, 0x6e, 0xde, 0x62, 0xaa, 0x40, 0xaa, 0xeb, 0x7a, 0xc7, 0x10, 0x4c, 0xef,
1170         0x88, 0xe5, 0xf7, 0xba, 0xde, 0xa9, 0xfd, 0x8b, 0xde, 0x41, 0x50, 0x4f, 0x19, 0x97, 0xb6, 0x47,
1171         0xf4, 0xf7, 0x7d, 0x95, 0xe7, 0x67, 0x5b, 0x53, 0xe5, 0xf6, 0x54, 0xb6, 0xca, 0xcb, 0x6a, 0xb6,
1172         0x56, 0xd4, 0x5c, 0x53, 0x97, 0xce, 0x3f, 0xae, 0xcb, 0x52, 0x35, 0x41, 0xb9, 0x9a, 0x94, 0x9e,
1173         0xe6, 0x40, 0x0f, 0xd0, 0xb3, 0x28, 0xc0, 0x7f, 0xd4, 0x33, 0xca, 0xe5, 0x7c, 0x50, 0x95, 0xde,
1174         0x43, 0xf3, 0x2a, 0x5d, 0x66, 0xbf, 0x56, 0xc8, 0xfe, 0x36, 0x34, 0xd4, 0xbd, 0xcc, 0x28, 0x6c,
1175         0x60, 0xb3, 0xf0, 0x3b, 0xe0, 0x0e, 0x19, 0xa7, 0x98, 0xfe, 0x96, 0x51, 0x21, 0xfd, 0xaf, 0xa1,
1176         0x6d, 0x96, 0x22, 0x65, 0x89, 0x79, 0x89, 0x0d, 0xa9, 0x5a, 0x24, 0x35, 0xa1, 0xfe, 0x81, 0x45,
1177         0x53, 0xff, 0xaf, 0x1a, 0xb4, 0x26, 0x21, 0x4d, 0x08, 0x8f, 0x98, 0x8a, 0x99, 0x90, 0x85, 0x29,
1178         0x36, 0x07, 0xeb, 0x6f, 0x74, 0x04, 0x9d, 0x7c, 0x00, 0x1a, 0x7d, 0x6a, 0x9f, 0xeb, 0x04, 0xdc,
1179         0x0e, 0x8b, 0x6f, 0xc5, 0x97, 0xe0, 0x26, 0xd9, 0xc2, 0x8e, 0xc5, 0xfc, 0xe8, 0x90, 0x64, 0x0b,
1180         0xc3, 0x51, 0x33, 0xda, 0x3e, 0x1b, 0x79, 0x84, 0xfa, 0xe7, 0xb4, 0xc1, 0x6d, 0x51, 0x6c, 0x15,
1181         0x1b, 0xc1, 0xd8, 0xf2, 0xf9, 0xac, 0x22, 0x18, 0x8e, 0x50, 0xcf, 0xd5, 0x2d, 0xe1, 0x8b, 0x2c,
1182         0x0d, 0x04, 0x0d, 0x59, 0x32, 0x15, 0x5e, 0x53, 0x63, 0x3a, 0xc6, 0x3a, 0x31, 0x46, 0xf5, 0x83,
1183         0x73, 0x49, 0x93, 0x70, 0xae, 0xb4, 0x5c, 0x22, 0x4d, 0x65, 0xf7, 0x96, 0x8e, 0x1c, 0xfc, 0x1a,
1184         0x3c, 0x91, 0x92, 0xdb, 0x24, 0x88, 0x59, 0x48, 0xe2, 0xe0, 0x96, 0xf1, 0x6b, 0x7d, 0x83, 0x2c,
1185         0xc9, 0xab, 0xfc, 0x91, 0xf6, 0x9f, 0x2a, 0xf7, 0xaf, 0xda, 0x3b, 0x54, 0x4e, 0x7f, 0x00, 0x4e,
1186         0x9e, 0x70, 0x81, 0x5e, 0x81, 0x23, 0xf2, 0x85, 0x7e, 0x43, 0xdd, 0xfe, 0x17, 0x2b, 0xf7, 0xb6,
1187         0x6e, 0x7c, 0x0f, 0x3c, 0x78, 0x91, 0xcf, 0x28, 0xdd, 0xee, 0x5b, 0xe0, 0x4e, 0x3e, 0x9e, 0x0d,
1188         0x83, 0xe1, 0xe9, 0xc9, 0xe8, 0xec, 0xa2, 0x57, 0x41, 0x3d, 0x68, 0x0f, 0x8a, 0x96, 0xea, 0xc1,
1189         0x49, 0xde, 0x04, 0x25, 0xc2, 0x64, 0x84, 0x3f, 0x8c, 0x70, 0x91, 0x60, 0x2d, 0x55, 0xe4, 0xc1,
1190         0xb6, 0xb1, 0xbc, 0x1d, 0x9d, 0x8d, 0xf0, 0xc9, 0xd2, 0x53, 0x3b, 0xf8, 0x0a, 0x36, 0xed, 0xbb,
1191         0x84, 0x1c, 0x68, 0xbc, 0x3f, 0x1b, 0xe0, 0x8f, 0xbd, 0x0a, 0xea, 0x80, 0x33, 0xb9, 0xc0, 0xa3,
1192         0xc1, 0xbb, 0x93, 0xb3, 0xb7, 0xbd, 0xea, 0x65, 0x53, 0xff, 0x12, 0x7f, 0xff, 0x77, 0x00, 0x00,
1193         0x00, 0xff, 0xff, 0x75, 0x59, 0xf4, 0x03, 0x4e, 0x0b, 0x00, 0x00,
1194 }