protocol/grpc/ricmsgcommrpc/rc/rc.pb.go

   1 // Code generated by protoc-gen-go.
   2 // source: rc.proto
   3 // DO NOT EDIT!
   4
   5 /*
   6 Package rc is a generated protocol buffer package.
   7
   8 It is generated from these files:
   9         rc.proto
  10
  11 It has these top-level messages:
  12         RICE2APHeader
  13         RICControlHeader
  14         UeId
  15         GNBUEID
  16         Guami
  17         RICControlMessage
  18         RicControlGrpcReq
  19         RicControlGrpcRsp
  20 */
  21 package rc
  22
  23 import proto "github.com/golang/protobuf/proto"
  24 import fmt "fmt"
  25 import math "math"
  26
  27 import (
  28         context "golang.org/x/net/context"
  29         grpc "google.golang.org/grpc"
  30 )
  31
  32 // Reference imports to suppress errors if they are not otherwise used.
  33 var _ = proto.Marshal
  34 var _ = fmt.Errorf
  35 var _ = math.Inf
  36
  37 // This is a compile-time assertion to ensure that this generated file
  38 // is compatible with the proto package it is being compiled against.
  39 // A compilation error at this line likely means your copy of the
  40 // proto package needs to be updated.
  41 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  42
  43 type RICControlCellTypeEnum int32
  44
  45 const (
  46         RICControlCellTypeEnum_RIC_CONTROL_CELL_UNKWON RICControlCellTypeEnum = 0
  47         RICControlCellTypeEnum_RIC_CONTROL_NR_CELL     RICControlCellTypeEnum = 1
  48         RICControlCellTypeEnum_RIC_CONTROL_EUTRAN_CELL RICControlCellTypeEnum = 2
  49 )
  50
  51 var RICControlCellTypeEnum_name = map[int32]string{
  52         0: "RIC_CONTROL_CELL_UNKWON",
  53         1: "RIC_CONTROL_NR_CELL",
  54         2: "RIC_CONTROL_EUTRAN_CELL",
  55 }
  56 var RICControlCellTypeEnum_value = map[string]int32{
  57         "RIC_CONTROL_CELL_UNKWON": 0,
  58         "RIC_CONTROL_NR_CELL":     1,
  59         "RIC_CONTROL_EUTRAN_CELL": 2,
  60 }
  61
  62 func (x RICControlCellTypeEnum) String() string {
  63         return proto.EnumName(RICControlCellTypeEnum_name, int32(x))
  64 }
  65 func (RICControlCellTypeEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  66
  67 type RICControlAckEnum int32
  68
  69 const (
  70         RICControlAckEnum_RIC_CONTROL_ACK_UNKWON RICControlAckEnum = 0
  71         RICControlAckEnum_RIC_CONTROL_NO_ACK     RICControlAckEnum = 1
  72         RICControlAckEnum_RIC_CONTROL_ACK        RICControlAckEnum = 2
  73         RICControlAckEnum_RIC_CONTROL_NACK       RICControlAckEnum = 3
  74 )
  75
  76 var RICControlAckEnum_name = map[int32]string{
  77         0: "RIC_CONTROL_ACK_UNKWON",
  78         1: "RIC_CONTROL_NO_ACK",
  79         2: "RIC_CONTROL_ACK",
  80         3: "RIC_CONTROL_NACK",
  81 }
  82 var RICControlAckEnum_value = map[string]int32{
  83         "RIC_CONTROL_ACK_UNKWON": 0,
  84         "RIC_CONTROL_NO_ACK":     1,
  85         "RIC_CONTROL_ACK":        2,
  86         "RIC_CONTROL_NACK":       3,
  87 }
  88
  89 func (x RICControlAckEnum) String() string {
  90         return proto.EnumName(RICControlAckEnum_name, int32(x))
  91 }
  92 func (RICControlAckEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
  93
  94 type RICE2APHeader struct {
  95         RanFuncId      int64 `protobuf:"varint,1,opt,name=RanFuncId" json:"RanFuncId,omitempty"`
  96         RICRequestorID int64 `protobuf:"varint,2,opt,name=RICRequestorID" json:"RICRequestorID,omitempty"`
  97 }
  98
  99 func (m *RICE2APHeader) Reset()                    { *m = RICE2APHeader{} }
 100 func (m *RICE2APHeader) String() string            { return proto.CompactTextString(m) }
 101 func (*RICE2APHeader) ProtoMessage()               {}
 102 func (*RICE2APHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 103
 104 func (m *RICE2APHeader) GetRanFuncId() int64 {
 105         if m != nil {
 106                 return m.RanFuncId
 107         }
 108         return 0
 109 }
 110
 111 func (m *RICE2APHeader) GetRICRequestorID() int64 {
 112         if m != nil {
 113                 return m.RICRequestorID
 114         }
 115         return 0
 116 }
 117
 118 type RICControlHeader struct {
 119         ControlStyle    int64 `protobuf:"varint,1,opt,name=ControlStyle" json:"ControlStyle,omitempty"`
 120         ControlActionId int64 `protobuf:"varint,2,opt,name=ControlActionId" json:"ControlActionId,omitempty"`
 121         UEID            *UeId `protobuf:"bytes,3,opt,name=UEID" json:"UEID,omitempty"`
 122 }
 123
 124 func (m *RICControlHeader) Reset()                    { *m = RICControlHeader{} }
 125 func (m *RICControlHeader) String() string            { return proto.CompactTextString(m) }
 126 func (*RICControlHeader) ProtoMessage()               {}
 127 func (*RICControlHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 128
 129 func (m *RICControlHeader) GetControlStyle() int64 {
 130         if m != nil {
 131                 return m.ControlStyle
 132         }
 133         return 0
 134 }
 135
 136 func (m *RICControlHeader) GetControlActionId() int64 {
 137         if m != nil {
 138                 return m.ControlActionId
 139         }
 140         return 0
 141 }
 142
 143 func (m *RICControlHeader) GetUEID() *UeId {
 144         if m != nil {
 145                 return m.UEID
 146         }
 147         return nil
 148 }
 149
 150 type UeId struct {
 151         GnbUEID *GNBUEID `protobuf:"bytes,1,opt,name=GnbUEID" json:"GnbUEID,omitempty"`
 152 }
 153
 154 func (m *UeId) Reset()                    { *m = UeId{} }
 155 func (m *UeId) String() string            { return proto.CompactTextString(m) }
 156 func (*UeId) ProtoMessage()               {}
 157 func (*UeId) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 158
 159 func (m *UeId) GetGnbUEID() *GNBUEID {
 160         if m != nil {
 161                 return m.GnbUEID
 162         }
 163         return nil
 164 }
 165
 166 type GNBUEID struct {
 167         AmfUENGAPID     int64   `protobuf:"varint,1,opt,name=amfUENGAPID" json:"amfUENGAPID,omitempty"`
 168         Guami           *Guami  `protobuf:"bytes,2,opt,name=guami" json:"guami,omitempty"`
 169         GNBCUUEF1APID   []int64 `protobuf:"varint,3,rep,packed,name=gNBCUUEF1APID" json:"gNBCUUEF1APID,omitempty"`
 170         GNBCUCPUEE1APID []int64 `protobuf:"varint,4,rep,packed,name=gNBCUCPUEE1APID" json:"gNBCUCPUEE1APID,omitempty"`
 171 }
 172
 173 func (m *GNBUEID) Reset()                    { *m = GNBUEID{} }
 174 func (m *GNBUEID) String() string            { return proto.CompactTextString(m) }
 175 func (*GNBUEID) ProtoMessage()               {}
 176 func (*GNBUEID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 177
 178 func (m *GNBUEID) GetAmfUENGAPID() int64 {
 179         if m != nil {
 180                 return m.AmfUENGAPID
 181         }
 182         return 0
 183 }
 184
 185 func (m *GNBUEID) GetGuami() *Guami {
 186         if m != nil {
 187                 return m.Guami
 188         }
 189         return nil
 190 }
 191
 192 func (m *GNBUEID) GetGNBCUUEF1APID() []int64 {
 193         if m != nil {
 194                 return m.GNBCUUEF1APID
 195         }
 196         return nil
 197 }
 198
 199 func (m *GNBUEID) GetGNBCUCPUEE1APID() []int64 {
 200         if m != nil {
 201                 return m.GNBCUCPUEE1APID
 202         }
 203         return nil
 204 }
 205
 206 type Guami struct {
 207         PLMNIdentity string `protobuf:"bytes,1,opt,name=pLMNIdentity" json:"pLMNIdentity,omitempty"`
 208         AMFRegionID  string `protobuf:"bytes,2,opt,name=aMFRegionID" json:"aMFRegionID,omitempty"`
 209         AMFSetID     string `protobuf:"bytes,3,opt,name=aMFSetID" json:"aMFSetID,omitempty"`
 210         AMFPointer   string `protobuf:"bytes,4,opt,name=aMFPointer" json:"aMFPointer,omitempty"`
 211 }
 212
 213 func (m *Guami) Reset()                    { *m = Guami{} }
 214 func (m *Guami) String() string            { return proto.CompactTextString(m) }
 215 func (*Guami) ProtoMessage()               {}
 216 func (*Guami) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 217
 218 func (m *Guami) GetPLMNIdentity() string {
 219         if m != nil {
 220                 return m.PLMNIdentity
 221         }
 222         return ""
 223 }
 224
 225 func (m *Guami) GetAMFRegionID() string {
 226         if m != nil {
 227                 return m.AMFRegionID
 228         }
 229         return ""
 230 }
 231
 232 func (m *Guami) GetAMFSetID() string {
 233         if m != nil {
 234                 return m.AMFSetID
 235         }
 236         return ""
 237 }
 238
 239 func (m *Guami) GetAMFPointer() string {
 240         if m != nil {
 241                 return m.AMFPointer
 242         }
 243         return ""
 244 }
 245
 246 type RICControlMessage struct {
 247         RICControlCellTypeVal RICControlCellTypeEnum `protobuf:"varint,1,opt,name=RICControlCellTypeVal,enum=rc.RICControlCellTypeEnum" json:"RICControlCellTypeVal,omitempty"`
 248         TargetCellID          string                 `protobuf:"bytes,2,opt,name=TargetCellID" json:"TargetCellID,omitempty"`
 249 }
 250
 251 func (m *RICControlMessage) Reset()                    { *m = RICControlMessage{} }
 252 func (m *RICControlMessage) String() string            { return proto.CompactTextString(m) }
 253 func (*RICControlMessage) ProtoMessage()               {}
 254 func (*RICControlMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 255
 256 func (m *RICControlMessage) GetRICControlCellTypeVal() RICControlCellTypeEnum {
 257         if m != nil {
 258                 return m.RICControlCellTypeVal
 259         }
 260         return RICControlCellTypeEnum_RIC_CONTROL_CELL_UNKWON
 261 }
 262
 263 func (m *RICControlMessage) GetTargetCellID() string {
 264         if m != nil {
 265                 return m.TargetCellID
 266         }
 267         return ""
 268 }
 269
 270 // RicControl GRPC Req
 271 type RicControlGrpcReq struct {
 272         E2NodeID              string             `protobuf:"bytes,1,opt,name=e2NodeID" json:"e2NodeID,omitempty"`
 273         PlmnID                string             `protobuf:"bytes,2,opt,name=plmnID" json:"plmnID,omitempty"`
 274         RanName               string             `protobuf:"bytes,3,opt,name=ranName" json:"ranName,omitempty"`
 275         RICE2APHeaderData     *RICE2APHeader     `protobuf:"bytes,4,opt,name=RICE2APHeaderData" json:"RICE2APHeaderData,omitempty"`
 276         RICControlHeaderData  *RICControlHeader  `protobuf:"bytes,5,opt,name=RICControlHeaderData" json:"RICControlHeaderData,omitempty"`
 277         RICControlMessageData *RICControlMessage `protobuf:"bytes,6,opt,name=RICControlMessageData" json:"RICControlMessageData,omitempty"`
 278         RICControlAckReqVal   RICControlAckEnum  `protobuf:"varint,7,opt,name=RICControlAckReqVal,enum=rc.RICControlAckEnum" json:"RICControlAckReqVal,omitempty"`
 279 }
 280
 281 func (m *RicControlGrpcReq) Reset()                    { *m = RicControlGrpcReq{} }
 282 func (m *RicControlGrpcReq) String() string            { return proto.CompactTextString(m) }
 283 func (*RicControlGrpcReq) ProtoMessage()               {}
 284 func (*RicControlGrpcReq) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 285
 286 func (m *RicControlGrpcReq) GetE2NodeID() string {
 287         if m != nil {
 288                 return m.E2NodeID
 289         }
 290         return ""
 291 }
 292
 293 func (m *RicControlGrpcReq) GetPlmnID() string {
 294         if m != nil {
 295                 return m.PlmnID
 296         }
 297         return ""
 298 }
 299
 300 func (m *RicControlGrpcReq) GetRanName() string {
 301         if m != nil {
 302                 return m.RanName
 303         }
 304         return ""
 305 }
 306
 307 func (m *RicControlGrpcReq) GetRICE2APHeaderData() *RICE2APHeader {
 308         if m != nil {
 309                 return m.RICE2APHeaderData
 310         }
 311         return nil
 312 }
 313
 314 func (m *RicControlGrpcReq) GetRICControlHeaderData() *RICControlHeader {
 315         if m != nil {
 316                 return m.RICControlHeaderData
 317         }
 318         return nil
 319 }
 320
 321 func (m *RicControlGrpcReq) GetRICControlMessageData() *RICControlMessage {
 322         if m != nil {
 323                 return m.RICControlMessageData
 324         }
 325         return nil
 326 }
 327
 328 func (m *RicControlGrpcReq) GetRICControlAckReqVal() RICControlAckEnum {
 329         if m != nil {
 330                 return m.RICControlAckReqVal
 331         }
 332         return RICControlAckEnum_RIC_CONTROL_ACK_UNKWON
 333 }
 334
 335 // RicControlGrpc Rsp
 336 type RicControlGrpcRsp struct {
 337         RspCode     int32  `protobuf:"varint,1,opt,name=rspCode" json:"rspCode,omitempty"`
 338         Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"`
 339 }
 340
 341 func (m *RicControlGrpcRsp) Reset()                    { *m = RicControlGrpcRsp{} }
 342 func (m *RicControlGrpcRsp) String() string            { return proto.CompactTextString(m) }
 343 func (*RicControlGrpcRsp) ProtoMessage()               {}
 344 func (*RicControlGrpcRsp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 345
 346 func (m *RicControlGrpcRsp) GetRspCode() int32 {
 347         if m != nil {
 348                 return m.RspCode
 349         }
 350         return 0
 351 }
 352
 353 func (m *RicControlGrpcRsp) GetDescription() string {
 354         if m != nil {
 355                 return m.Description
 356         }
 357         return ""
 358 }
 359
 360 func init() {
 361         proto.RegisterType((*RICE2APHeader)(nil), "rc.RICE2APHeader")
 362         proto.RegisterType((*RICControlHeader)(nil), "rc.RICControlHeader")
 363         proto.RegisterType((*UeId)(nil), "rc.UeId")
 364         proto.RegisterType((*GNBUEID)(nil), "rc.gNBUEID")
 365         proto.RegisterType((*Guami)(nil), "rc.Guami")
 366         proto.RegisterType((*RICControlMessage)(nil), "rc.RICControlMessage")
 367         proto.RegisterType((*RicControlGrpcReq)(nil), "rc.RicControlGrpcReq")
 368         proto.RegisterType((*RicControlGrpcRsp)(nil), "rc.RicControlGrpcRsp")
 369         proto.RegisterEnum("rc.RICControlCellTypeEnum", RICControlCellTypeEnum_name, RICControlCellTypeEnum_value)
 370         proto.RegisterEnum("rc.RICControlAckEnum", RICControlAckEnum_name, RICControlAckEnum_value)
 371 }
 372
 373 // Reference imports to suppress errors if they are not otherwise used.
 374 var _ context.Context
 375 var _ grpc.ClientConn
 376
 377 // This is a compile-time assertion to ensure that this generated file
 378 // is compatible with the grpc package it is being compiled against.
 379 const _ = grpc.SupportPackageIsVersion4
 380
 381 // Client API for MsgComm service
 382
 383 type MsgCommClient interface {
 384         // gRPC call to Send RICControlReqServiceGrpc
 385         SendRICControlReqServiceGrpc(ctx context.Context, in *RicControlGrpcReq, opts ...grpc.CallOption) (*RicControlGrpcRsp, error)
 386 }
 387
 388 type msgCommClient struct {
 389         cc *grpc.ClientConn
 390 }
 391
 392 func NewMsgCommClient(cc *grpc.ClientConn) MsgCommClient {
 393         return &msgCommClient{cc}
 394 }
 395
 396 func (c *msgCommClient) SendRICControlReqServiceGrpc(ctx context.Context, in *RicControlGrpcReq, opts ...grpc.CallOption) (*RicControlGrpcRsp, error) {
 397         out := new(RicControlGrpcRsp)
 398         err := grpc.Invoke(ctx, "/rc.MsgComm/SendRICControlReqServiceGrpc", in, out, c.cc, opts...)
 399         if err != nil {
 400                 return nil, err
 401         }
 402         return out, nil
 403 }
 404
 405 // Server API for MsgComm service
 406
 407 type MsgCommServer interface {
 408         // gRPC call to Send RICControlReqServiceGrpc
 409         SendRICControlReqServiceGrpc(context.Context, *RicControlGrpcReq) (*RicControlGrpcRsp, error)
 410 }
 411
 412 func RegisterMsgCommServer(s *grpc.Server, srv MsgCommServer) {
 413         s.RegisterService(&_MsgComm_serviceDesc, srv)
 414 }
 415
 416 func _MsgComm_SendRICControlReqServiceGrpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 417         in := new(RicControlGrpcReq)
 418         if err := dec(in); err != nil {
 419                 return nil, err
 420         }
 421         if interceptor == nil {
 422                 return srv.(MsgCommServer).SendRICControlReqServiceGrpc(ctx, in)
 423         }
 424         info := &grpc.UnaryServerInfo{
 425                 Server:     srv,
 426                 FullMethod: "/rc.MsgComm/SendRICControlReqServiceGrpc",
 427         }
 428         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 429                 return srv.(MsgCommServer).SendRICControlReqServiceGrpc(ctx, req.(*RicControlGrpcReq))
 430         }
 431         return interceptor(ctx, in, info, handler)
 432 }
 433
 434 var _MsgComm_serviceDesc = grpc.ServiceDesc{
 435         ServiceName: "rc.MsgComm",
 436         HandlerType: (*MsgCommServer)(nil),
 437         Methods: []grpc.MethodDesc{
 438                 {
 439                         MethodName: "SendRICControlReqServiceGrpc",
 440                         Handler:    _MsgComm_SendRICControlReqServiceGrpc_Handler,
 441                 },
 442         },
 443         Streams:  []grpc.StreamDesc{},
 444         Metadata: "rc.proto",
 445 }
 446
 447 func init() { proto.RegisterFile("rc.proto", fileDescriptor0) }
 448
 449 var fileDescriptor0 = []byte{
 450         // 692 bytes of a gzipped FileDescriptorProto
 451         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x94, 0xcd, 0x6e, 0xda, 0x40,
 452         0x10, 0xc7, 0x6b, 0x0c, 0x21, 0x0c, 0x4d, 0x42, 0x36, 0x5f, 0x88, 0x46, 0x2d, 0xb2, 0xda, 0x0a,
 453         0x45, 0x6a, 0xa4, 0xd2, 0x07, 0xa8, 0x88, 0x63, 0x88, 0x15, 0x30, 0x68, 0xc0, 0xcd, 0x31, 0x72,
 454         0xec, 0x2d, 0x42, 0xc1, 0x1f, 0xac, 0x4d, 0xa5, 0x5c, 0x7a, 0xe8, 0xad, 0xef, 0xd0, 0x87, 0xad,
 455         0x76, 0x59, 0x30, 0x76, 0x38, 0xce, 0x6f, 0x3e, 0x76, 0xe6, 0x3f, 0xbb, 0x0b, 0xfb, 0xcc, 0xbd,
 456         0x8e, 0x58, 0x98, 0x84, 0xa4, 0xc0, 0x5c, 0xcd, 0x86, 0x03, 0x34, 0x75, 0xa3, 0xdd, 0x19, 0xdd,
 457         0x51, 0xc7, 0xa3, 0x8c, 0x5c, 0x42, 0x05, 0x9d, 0xa0, 0xbb, 0x0c, 0x5c, 0xd3, 0xab, 0x2b, 0x4d,
 458         0xa5, 0xa5, 0x62, 0x0a, 0xc8, 0x67, 0x38, 0x44, 0x53, 0x47, 0xba, 0x58, 0xd2, 0x38, 0x09, 0x99,
 459         0x79, 0x5b, 0x2f, 0x88, 0x90, 0x1c, 0xd5, 0x7e, 0x43, 0x0d, 0x4d, 0x5d, 0x0f, 0x83, 0x84, 0x85,
 460         0x73, 0x59, 0x59, 0x83, 0xb7, 0x12, 0x8c, 0x93, 0x97, 0x39, 0x95, 0xc5, 0x33, 0x8c, 0xb4, 0xe0,
 461         0x48, 0xda, 0x1d, 0x37, 0x99, 0x85, 0x81, 0xe9, 0xc9, 0x03, 0xf2, 0x98, 0x5c, 0x42, 0xd1, 0x36,
 462         0xcc, 0xdb, 0xba, 0xda, 0x54, 0x5a, 0xd5, 0xf6, 0xfe, 0x35, 0x73, 0xaf, 0x6d, 0x6a, 0x7a, 0x28,
 463         0xa8, 0xf6, 0x05, 0x8a, 0xdc, 0x22, 0x9f, 0xa0, 0xdc, 0x0b, 0x9e, 0x44, 0xa0, 0x22, 0x02, 0xab,
 464         0x3c, 0x70, 0x6a, 0xdd, 0x70, 0x84, 0x6b, 0x9f, 0xf6, 0x4f, 0x81, 0xb2, 0x84, 0xa4, 0x09, 0x55,
 465         0xc7, 0xff, 0x69, 0x1b, 0x56, 0xaf, 0x33, 0x92, 0x69, 0x2a, 0x6e, 0x23, 0xf2, 0x01, 0x4a, 0xd3,
 466         0xa5, 0xe3, 0xcf, 0x44, 0x6b, 0xd5, 0x76, 0x85, 0x97, 0xec, 0x71, 0x80, 0x2b, 0x4e, 0x3e, 0xc2,
 467         0xc1, 0xd4, 0xba, 0xd1, 0x6d, 0xdb, 0xe8, 0x7e, 0x15, 0x45, 0xd4, 0xa6, 0xda, 0x52, 0x31, 0x0b,
 468         0xf9, 0xac, 0x02, 0xe8, 0x23, 0xdb, 0x30, 0x56, 0x71, 0x45, 0x11, 0x97, 0xc7, 0xda, 0x5f, 0x05,
 469         0x4a, 0xe2, 0x00, 0xae, 0x61, 0xd4, 0x1f, 0x58, 0xa6, 0x47, 0x83, 0x64, 0x96, 0xbc, 0x88, 0xee,
 470         0x2a, 0x98, 0x61, 0x62, 0x80, 0x41, 0x17, 0xe9, 0x94, 0x0b, 0xb5, 0x5a, 0x50, 0x05, 0xb7, 0x11,
 471         0x69, 0xc0, 0xbe, 0x33, 0xe8, 0x8e, 0x69, 0x22, 0xf5, 0xab, 0xe0, 0xc6, 0x26, 0xef, 0x01, 0x9c,
 472         0x41, 0x77, 0x14, 0xce, 0x82, 0x84, 0xb2, 0x7a, 0x51, 0x78, 0xb7, 0x08, 0xef, 0xe5, 0x38, 0x5d,
 473         0xed, 0x80, 0xc6, 0xb1, 0x33, 0xa5, 0x64, 0x04, 0x67, 0x29, 0xd4, 0xe9, 0x7c, 0x3e, 0x79, 0x89,
 474         0xe8, 0x0f, 0x67, 0x2e, 0x1a, 0x3c, 0x6c, 0x37, 0xb8, 0x44, 0xaf, 0x03, 0x8c, 0x60, 0xe9, 0xe3,
 475         0xee, 0x44, 0x3e, 0xe9, 0xc4, 0x61, 0x53, 0x9a, 0x70, 0xb8, 0x19, 0x23, 0xc3, 0xb4, 0x3f, 0x2a,
 476         0x1c, 0xe3, 0xcc, 0x95, 0xd9, 0x3d, 0x16, 0xb9, 0x48, 0x17, 0x7c, 0x3a, 0xda, 0xb6, 0x42, 0x8f,
 477         0xca, 0xed, 0x55, 0x70, 0x63, 0x93, 0x73, 0xd8, 0x8b, 0xe6, 0x7e, 0x2a, 0x8b, 0xb4, 0x48, 0x1d,
 478         0xca, 0xcc, 0x09, 0x2c, 0xc7, 0xa7, 0x52, 0x90, 0xb5, 0x49, 0xbe, 0x8b, 0x71, 0xd3, 0x07, 0x72,
 479         0xeb, 0x24, 0x8e, 0x90, 0xa5, 0xda, 0x3e, 0x96, 0x53, 0xa5, 0x4e, 0x7c, 0x1d, 0x4b, 0xee, 0xe0,
 480         0x34, 0xff, 0x14, 0x44, 0x8d, 0x92, 0xa8, 0x71, 0x9a, 0x55, 0x46, 0x96, 0xd9, 0x99, 0x41, 0xee,
 481         0xb7, 0x45, 0x96, 0xca, 0x8b, 0x52, 0x7b, 0xa2, 0xd4, 0x59, 0xb6, 0x94, 0x0c, 0xc0, 0xdd, 0x39,
 482         0xa4, 0x07, 0x27, 0xa9, 0xa3, 0xe3, 0x3e, 0x23, 0x5d, 0xf0, 0x7d, 0x95, 0xc5, 0xbe, 0x72, 0xa5,
 483         0x3a, 0xee, 0xb3, 0x58, 0xd5, 0xae, 0x0c, 0x6d, 0xf8, 0x6a, 0x07, 0x71, 0x24, 0xf4, 0x8c, 0x23,
 484         0x3d, 0xf4, 0x56, 0xcf, 0xbc, 0x84, 0x6b, 0x93, 0xdf, 0x4e, 0x8f, 0xc6, 0x2e, 0x9b, 0x45, 0xfc,
 485         0x21, 0xaf, 0x6f, 0xe7, 0x16, 0xba, 0x7a, 0x86, 0xf3, 0xdd, 0x57, 0x85, 0xbc, 0x83, 0x0b, 0x34,
 486         0xf5, 0x47, 0x7d, 0x68, 0x4d, 0x70, 0xd8, 0x7f, 0xd4, 0x8d, 0x7e, 0xff, 0xd1, 0xb6, 0xee, 0x1f,
 487         0x86, 0x56, 0xed, 0x0d, 0xb9, 0x10, 0x03, 0x6d, 0x9c, 0x16, 0x0a, 0x7f, 0x4d, 0xc9, 0x67, 0x19,
 488         0xf6, 0x04, 0x3b, 0xd6, 0xca, 0x59, 0xb8, 0x62, 0xdb, 0xb7, 0x59, 0xce, 0x49, 0x1a, 0xa2, 0x83,
 489         0x4d, 0x46, 0x47, 0xbf, 0x4f, 0x8f, 0x39, 0x07, 0x92, 0x39, 0x66, 0xc8, 0xdd, 0x35, 0x85, 0x9c,
 490         0xc0, 0x51, 0x2e, 0xa7, 0x56, 0x20, 0xa7, 0xe2, 0x1b, 0x4c, 0x83, 0x39, 0x55, 0xdb, 0x0f, 0x50,
 491         0x1e, 0xc4, 0x53, 0x3d, 0xf4, 0x7d, 0xd2, 0x87, 0xcb, 0x31, 0x0d, 0xbc, 0xb4, 0x05, 0xa4, 0x8b,
 492         0x31, 0x65, 0xbf, 0x66, 0x2e, 0xe5, 0x52, 0x92, 0xd5, 0x22, 0xf2, 0x57, 0xbc, 0xb1, 0x0b, 0xc7,
 493         0xd1, 0xd3, 0x9e, 0xf8, 0xd7, 0xbf, 0xfd, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x53, 0x8b, 0xc3,
 494         0xe3, 0x05, 0x00, 0x00,
 495 }