cmd/bpa-operator/vendor/k8s.io/api/scheduling/v1alpha1/generated.pb.go

   1 /*
   2 Copyright The Kubernetes Authors.
   3
   4 Licensed under the Apache License, Version 2.0 (the "License");
   5 you may not use this file except in compliance with the License.
   6 You may obtain a copy of the License at
   7
   8     http://www.apache.org/licenses/LICENSE-2.0
   9
  10 Unless required by applicable law or agreed to in writing, software
  11 distributed under the License is distributed on an "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 See the License for the specific language governing permissions and
  14 limitations under the License.
  15 */
  16
  17 // Code generated by protoc-gen-gogo. DO NOT EDIT.
  18 // source: k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1alpha1/generated.proto
  19
  20 /*
  21         Package v1alpha1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1alpha1/generated.proto
  25
  26         It has these top-level messages:
  27                 PriorityClass
  28                 PriorityClassList
  29 */
  30 package v1alpha1
  31
  32 import proto "github.com/gogo/protobuf/proto"
  33 import fmt "fmt"
  34 import math "math"
  35
  36 import strings "strings"
  37 import reflect "reflect"
  38
  39 import io "io"
  40
  41 // Reference imports to suppress errors if they are not otherwise used.
  42 var _ = proto.Marshal
  43 var _ = fmt.Errorf
  44 var _ = math.Inf
  45
  46 // This is a compile-time assertion to ensure that this generated file
  47 // is compatible with the proto package it is being compiled against.
  48 // A compilation error at this line likely means your copy of the
  49 // proto package needs to be updated.
  50 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  51
  52 func (m *PriorityClass) Reset()                    { *m = PriorityClass{} }
  53 func (*PriorityClass) ProtoMessage()               {}
  54 func (*PriorityClass) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  55
  56 func (m *PriorityClassList) Reset()                    { *m = PriorityClassList{} }
  57 func (*PriorityClassList) ProtoMessage()               {}
  58 func (*PriorityClassList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  59
  60 func init() {
  61         proto.RegisterType((*PriorityClass)(nil), "k8s.io.api.scheduling.v1alpha1.PriorityClass")
  62         proto.RegisterType((*PriorityClassList)(nil), "k8s.io.api.scheduling.v1alpha1.PriorityClassList")
  63 }
  64 func (m *PriorityClass) Marshal() (dAtA []byte, err error) {
  65         size := m.Size()
  66         dAtA = make([]byte, size)
  67         n, err := m.MarshalTo(dAtA)
  68         if err != nil {
  69                 return nil, err
  70         }
  71         return dAtA[:n], nil
  72 }
  73
  74 func (m *PriorityClass) MarshalTo(dAtA []byte) (int, error) {
  75         var i int
  76         _ = i
  77         var l int
  78         _ = l
  79         dAtA[i] = 0xa
  80         i++
  81         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
  82         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
  83         if err != nil {
  84                 return 0, err
  85         }
  86         i += n1
  87         dAtA[i] = 0x10
  88         i++
  89         i = encodeVarintGenerated(dAtA, i, uint64(m.Value))
  90         dAtA[i] = 0x18
  91         i++
  92         if m.GlobalDefault {
  93                 dAtA[i] = 1
  94         } else {
  95                 dAtA[i] = 0
  96         }
  97         i++
  98         dAtA[i] = 0x22
  99         i++
 100         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description)))
 101         i += copy(dAtA[i:], m.Description)
 102         return i, nil
 103 }
 104
 105 func (m *PriorityClassList) Marshal() (dAtA []byte, err error) {
 106         size := m.Size()
 107         dAtA = make([]byte, size)
 108         n, err := m.MarshalTo(dAtA)
 109         if err != nil {
 110                 return nil, err
 111         }
 112         return dAtA[:n], nil
 113 }
 114
 115 func (m *PriorityClassList) MarshalTo(dAtA []byte) (int, error) {
 116         var i int
 117         _ = i
 118         var l int
 119         _ = l
 120         dAtA[i] = 0xa
 121         i++
 122         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 123         n2, err := m.ListMeta.MarshalTo(dAtA[i:])
 124         if err != nil {
 125                 return 0, err
 126         }
 127         i += n2
 128         if len(m.Items) > 0 {
 129                 for _, msg := range m.Items {
 130                         dAtA[i] = 0x12
 131                         i++
 132                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 133                         n, err := msg.MarshalTo(dAtA[i:])
 134                         if err != nil {
 135                                 return 0, err
 136                         }
 137                         i += n
 138                 }
 139         }
 140         return i, nil
 141 }
 142
 143 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 144         for v >= 1<<7 {
 145                 dAtA[offset] = uint8(v&0x7f | 0x80)
 146                 v >>= 7
 147                 offset++
 148         }
 149         dAtA[offset] = uint8(v)
 150         return offset + 1
 151 }
 152 func (m *PriorityClass) Size() (n int) {
 153         var l int
 154         _ = l
 155         l = m.ObjectMeta.Size()
 156         n += 1 + l + sovGenerated(uint64(l))
 157         n += 1 + sovGenerated(uint64(m.Value))
 158         n += 2
 159         l = len(m.Description)
 160         n += 1 + l + sovGenerated(uint64(l))
 161         return n
 162 }
 163
 164 func (m *PriorityClassList) Size() (n int) {
 165         var l int
 166         _ = l
 167         l = m.ListMeta.Size()
 168         n += 1 + l + sovGenerated(uint64(l))
 169         if len(m.Items) > 0 {
 170                 for _, e := range m.Items {
 171                         l = e.Size()
 172                         n += 1 + l + sovGenerated(uint64(l))
 173                 }
 174         }
 175         return n
 176 }
 177
 178 func sovGenerated(x uint64) (n int) {
 179         for {
 180                 n++
 181                 x >>= 7
 182                 if x == 0 {
 183                         break
 184                 }
 185         }
 186         return n
 187 }
 188 func sozGenerated(x uint64) (n int) {
 189         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 190 }
 191 func (this *PriorityClass) String() string {
 192         if this == nil {
 193                 return "nil"
 194         }
 195         s := strings.Join([]string{`&PriorityClass{`,
 196                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 197                 `Value:` + fmt.Sprintf("%v", this.Value) + `,`,
 198                 `GlobalDefault:` + fmt.Sprintf("%v", this.GlobalDefault) + `,`,
 199                 `Description:` + fmt.Sprintf("%v", this.Description) + `,`,
 200                 `}`,
 201         }, "")
 202         return s
 203 }
 204 func (this *PriorityClassList) String() string {
 205         if this == nil {
 206                 return "nil"
 207         }
 208         s := strings.Join([]string{`&PriorityClassList{`,
 209                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 210                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PriorityClass", "PriorityClass", 1), `&`, ``, 1) + `,`,
 211                 `}`,
 212         }, "")
 213         return s
 214 }
 215 func valueToStringGenerated(v interface{}) string {
 216         rv := reflect.ValueOf(v)
 217         if rv.IsNil() {
 218                 return "nil"
 219         }
 220         pv := reflect.Indirect(rv).Interface()
 221         return fmt.Sprintf("*%v", pv)
 222 }
 223 func (m *PriorityClass) Unmarshal(dAtA []byte) error {
 224         l := len(dAtA)
 225         iNdEx := 0
 226         for iNdEx < l {
 227                 preIndex := iNdEx
 228                 var wire uint64
 229                 for shift := uint(0); ; shift += 7 {
 230                         if shift >= 64 {
 231                                 return ErrIntOverflowGenerated
 232                         }
 233                         if iNdEx >= l {
 234                                 return io.ErrUnexpectedEOF
 235                         }
 236                         b := dAtA[iNdEx]
 237                         iNdEx++
 238                         wire |= (uint64(b) & 0x7F) << shift
 239                         if b < 0x80 {
 240                                 break
 241                         }
 242                 }
 243                 fieldNum := int32(wire >> 3)
 244                 wireType := int(wire & 0x7)
 245                 if wireType == 4 {
 246                         return fmt.Errorf("proto: PriorityClass: wiretype end group for non-group")
 247                 }
 248                 if fieldNum <= 0 {
 249                         return fmt.Errorf("proto: PriorityClass: illegal tag %d (wire type %d)", fieldNum, wire)
 250                 }
 251                 switch fieldNum {
 252                 case 1:
 253                         if wireType != 2 {
 254                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 255                         }
 256                         var msglen int
 257                         for shift := uint(0); ; shift += 7 {
 258                                 if shift >= 64 {
 259                                         return ErrIntOverflowGenerated
 260                                 }
 261                                 if iNdEx >= l {
 262                                         return io.ErrUnexpectedEOF
 263                                 }
 264                                 b := dAtA[iNdEx]
 265                                 iNdEx++
 266                                 msglen |= (int(b) & 0x7F) << shift
 267                                 if b < 0x80 {
 268                                         break
 269                                 }
 270                         }
 271                         if msglen < 0 {
 272                                 return ErrInvalidLengthGenerated
 273                         }
 274                         postIndex := iNdEx + msglen
 275                         if postIndex > l {
 276                                 return io.ErrUnexpectedEOF
 277                         }
 278                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 279                                 return err
 280                         }
 281                         iNdEx = postIndex
 282                 case 2:
 283                         if wireType != 0 {
 284                                 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 285                         }
 286                         m.Value = 0
 287                         for shift := uint(0); ; shift += 7 {
 288                                 if shift >= 64 {
 289                                         return ErrIntOverflowGenerated
 290                                 }
 291                                 if iNdEx >= l {
 292                                         return io.ErrUnexpectedEOF
 293                                 }
 294                                 b := dAtA[iNdEx]
 295                                 iNdEx++
 296                                 m.Value |= (int32(b) & 0x7F) << shift
 297                                 if b < 0x80 {
 298                                         break
 299                                 }
 300                         }
 301                 case 3:
 302                         if wireType != 0 {
 303                                 return fmt.Errorf("proto: wrong wireType = %d for field GlobalDefault", wireType)
 304                         }
 305                         var v int
 306                         for shift := uint(0); ; shift += 7 {
 307                                 if shift >= 64 {
 308                                         return ErrIntOverflowGenerated
 309                                 }
 310                                 if iNdEx >= l {
 311                                         return io.ErrUnexpectedEOF
 312                                 }
 313                                 b := dAtA[iNdEx]
 314                                 iNdEx++
 315                                 v |= (int(b) & 0x7F) << shift
 316                                 if b < 0x80 {
 317                                         break
 318                                 }
 319                         }
 320                         m.GlobalDefault = bool(v != 0)
 321                 case 4:
 322                         if wireType != 2 {
 323                                 return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
 324                         }
 325                         var stringLen uint64
 326                         for shift := uint(0); ; shift += 7 {
 327                                 if shift >= 64 {
 328                                         return ErrIntOverflowGenerated
 329                                 }
 330                                 if iNdEx >= l {
 331                                         return io.ErrUnexpectedEOF
 332                                 }
 333                                 b := dAtA[iNdEx]
 334                                 iNdEx++
 335                                 stringLen |= (uint64(b) & 0x7F) << shift
 336                                 if b < 0x80 {
 337                                         break
 338                                 }
 339                         }
 340                         intStringLen := int(stringLen)
 341                         if intStringLen < 0 {
 342                                 return ErrInvalidLengthGenerated
 343                         }
 344                         postIndex := iNdEx + intStringLen
 345                         if postIndex > l {
 346                                 return io.ErrUnexpectedEOF
 347                         }
 348                         m.Description = string(dAtA[iNdEx:postIndex])
 349                         iNdEx = postIndex
 350                 default:
 351                         iNdEx = preIndex
 352                         skippy, err := skipGenerated(dAtA[iNdEx:])
 353                         if err != nil {
 354                                 return err
 355                         }
 356                         if skippy < 0 {
 357                                 return ErrInvalidLengthGenerated
 358                         }
 359                         if (iNdEx + skippy) > l {
 360                                 return io.ErrUnexpectedEOF
 361                         }
 362                         iNdEx += skippy
 363                 }
 364         }
 365
 366         if iNdEx > l {
 367                 return io.ErrUnexpectedEOF
 368         }
 369         return nil
 370 }
 371 func (m *PriorityClassList) Unmarshal(dAtA []byte) error {
 372         l := len(dAtA)
 373         iNdEx := 0
 374         for iNdEx < l {
 375                 preIndex := iNdEx
 376                 var wire uint64
 377                 for shift := uint(0); ; shift += 7 {
 378                         if shift >= 64 {
 379                                 return ErrIntOverflowGenerated
 380                         }
 381                         if iNdEx >= l {
 382                                 return io.ErrUnexpectedEOF
 383                         }
 384                         b := dAtA[iNdEx]
 385                         iNdEx++
 386                         wire |= (uint64(b) & 0x7F) << shift
 387                         if b < 0x80 {
 388                                 break
 389                         }
 390                 }
 391                 fieldNum := int32(wire >> 3)
 392                 wireType := int(wire & 0x7)
 393                 if wireType == 4 {
 394                         return fmt.Errorf("proto: PriorityClassList: wiretype end group for non-group")
 395                 }
 396                 if fieldNum <= 0 {
 397                         return fmt.Errorf("proto: PriorityClassList: illegal tag %d (wire type %d)", fieldNum, wire)
 398                 }
 399                 switch fieldNum {
 400                 case 1:
 401                         if wireType != 2 {
 402                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 403                         }
 404                         var msglen int
 405                         for shift := uint(0); ; shift += 7 {
 406                                 if shift >= 64 {
 407                                         return ErrIntOverflowGenerated
 408                                 }
 409                                 if iNdEx >= l {
 410                                         return io.ErrUnexpectedEOF
 411                                 }
 412                                 b := dAtA[iNdEx]
 413                                 iNdEx++
 414                                 msglen |= (int(b) & 0x7F) << shift
 415                                 if b < 0x80 {
 416                                         break
 417                                 }
 418                         }
 419                         if msglen < 0 {
 420                                 return ErrInvalidLengthGenerated
 421                         }
 422                         postIndex := iNdEx + msglen
 423                         if postIndex > l {
 424                                 return io.ErrUnexpectedEOF
 425                         }
 426                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 427                                 return err
 428                         }
 429                         iNdEx = postIndex
 430                 case 2:
 431                         if wireType != 2 {
 432                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 433                         }
 434                         var msglen int
 435                         for shift := uint(0); ; shift += 7 {
 436                                 if shift >= 64 {
 437                                         return ErrIntOverflowGenerated
 438                                 }
 439                                 if iNdEx >= l {
 440                                         return io.ErrUnexpectedEOF
 441                                 }
 442                                 b := dAtA[iNdEx]
 443                                 iNdEx++
 444                                 msglen |= (int(b) & 0x7F) << shift
 445                                 if b < 0x80 {
 446                                         break
 447                                 }
 448                         }
 449                         if msglen < 0 {
 450                                 return ErrInvalidLengthGenerated
 451                         }
 452                         postIndex := iNdEx + msglen
 453                         if postIndex > l {
 454                                 return io.ErrUnexpectedEOF
 455                         }
 456                         m.Items = append(m.Items, PriorityClass{})
 457                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 458                                 return err
 459                         }
 460                         iNdEx = postIndex
 461                 default:
 462                         iNdEx = preIndex
 463                         skippy, err := skipGenerated(dAtA[iNdEx:])
 464                         if err != nil {
 465                                 return err
 466                         }
 467                         if skippy < 0 {
 468                                 return ErrInvalidLengthGenerated
 469                         }
 470                         if (iNdEx + skippy) > l {
 471                                 return io.ErrUnexpectedEOF
 472                         }
 473                         iNdEx += skippy
 474                 }
 475         }
 476
 477         if iNdEx > l {
 478                 return io.ErrUnexpectedEOF
 479         }
 480         return nil
 481 }
 482 func skipGenerated(dAtA []byte) (n int, err error) {
 483         l := len(dAtA)
 484         iNdEx := 0
 485         for iNdEx < l {
 486                 var wire uint64
 487                 for shift := uint(0); ; shift += 7 {
 488                         if shift >= 64 {
 489                                 return 0, ErrIntOverflowGenerated
 490                         }
 491                         if iNdEx >= l {
 492                                 return 0, io.ErrUnexpectedEOF
 493                         }
 494                         b := dAtA[iNdEx]
 495                         iNdEx++
 496                         wire |= (uint64(b) & 0x7F) << shift
 497                         if b < 0x80 {
 498                                 break
 499                         }
 500                 }
 501                 wireType := int(wire & 0x7)
 502                 switch wireType {
 503                 case 0:
 504                         for shift := uint(0); ; shift += 7 {
 505                                 if shift >= 64 {
 506                                         return 0, ErrIntOverflowGenerated
 507                                 }
 508                                 if iNdEx >= l {
 509                                         return 0, io.ErrUnexpectedEOF
 510                                 }
 511                                 iNdEx++
 512                                 if dAtA[iNdEx-1] < 0x80 {
 513                                         break
 514                                 }
 515                         }
 516                         return iNdEx, nil
 517                 case 1:
 518                         iNdEx += 8
 519                         return iNdEx, nil
 520                 case 2:
 521                         var length int
 522                         for shift := uint(0); ; shift += 7 {
 523                                 if shift >= 64 {
 524                                         return 0, ErrIntOverflowGenerated
 525                                 }
 526                                 if iNdEx >= l {
 527                                         return 0, io.ErrUnexpectedEOF
 528                                 }
 529                                 b := dAtA[iNdEx]
 530                                 iNdEx++
 531                                 length |= (int(b) & 0x7F) << shift
 532                                 if b < 0x80 {
 533                                         break
 534                                 }
 535                         }
 536                         iNdEx += length
 537                         if length < 0 {
 538                                 return 0, ErrInvalidLengthGenerated
 539                         }
 540                         return iNdEx, nil
 541                 case 3:
 542                         for {
 543                                 var innerWire uint64
 544                                 var start int = iNdEx
 545                                 for shift := uint(0); ; shift += 7 {
 546                                         if shift >= 64 {
 547                                                 return 0, ErrIntOverflowGenerated
 548                                         }
 549                                         if iNdEx >= l {
 550                                                 return 0, io.ErrUnexpectedEOF
 551                                         }
 552                                         b := dAtA[iNdEx]
 553                                         iNdEx++
 554                                         innerWire |= (uint64(b) & 0x7F) << shift
 555                                         if b < 0x80 {
 556                                                 break
 557                                         }
 558                                 }
 559                                 innerWireType := int(innerWire & 0x7)
 560                                 if innerWireType == 4 {
 561                                         break
 562                                 }
 563                                 next, err := skipGenerated(dAtA[start:])
 564                                 if err != nil {
 565                                         return 0, err
 566                                 }
 567                                 iNdEx = start + next
 568                         }
 569                         return iNdEx, nil
 570                 case 4:
 571                         return iNdEx, nil
 572                 case 5:
 573                         iNdEx += 4
 574                         return iNdEx, nil
 575                 default:
 576                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 577                 }
 578         }
 579         panic("unreachable")
 580 }
 581
 582 var (
 583         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
 584         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
 585 )
 586
 587 func init() {
 588         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/scheduling/v1alpha1/generated.proto", fileDescriptorGenerated)
 589 }
 590
 591 var fileDescriptorGenerated = []byte{
 592         // 447 bytes of a gzipped FileDescriptorProto
 593         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x8b, 0xd3, 0x40,
 594         0x18, 0xc6, 0x33, 0x5d, 0x0b, 0x75, 0x4a, 0x41, 0x23, 0x42, 0xe8, 0x61, 0x36, 0xac, 0x97, 0x5c,
 595         0x76, 0xc6, 0x2e, 0x2a, 0x82, 0xb7, 0xb8, 0xb0, 0x08, 0x8a, 0x92, 0x83, 0x07, 0xf1, 0xe0, 0x24,
 596         0x79, 0x37, 0x1d, 0x9b, 0x64, 0xc2, 0xcc, 0x24, 0xb0, 0x37, 0xcf, 0x9e, 0xfc, 0x52, 0x42, 0x8f,
 597         0x7b, 0xdc, 0xd3, 0x62, 0xe3, 0x17, 0x91, 0xa4, 0x69, 0xd3, 0x5a, 0xfc, 0x73, 0xcb, 0x3c, 0xef,
 598         0xef, 0x79, 0xe6, 0xcd, 0xc3, 0xe0, 0x8b, 0xc5, 0x73, 0x4d, 0x85, 0x64, 0x8b, 0x32, 0x04, 0x95,
 599         0x83, 0x01, 0xcd, 0x2a, 0xc8, 0x63, 0xa9, 0x58, 0x37, 0xe0, 0x85, 0x60, 0x3a, 0x9a, 0x43, 0x5c,
 600         0xa6, 0x22, 0x4f, 0x58, 0x35, 0xe3, 0x69, 0x31, 0xe7, 0x33, 0x96, 0x40, 0x0e, 0x8a, 0x1b, 0x88,
 601         0x69, 0xa1, 0xa4, 0x91, 0x36, 0x59, 0xf3, 0x94, 0x17, 0x82, 0xf6, 0x3c, 0xdd, 0xf0, 0xd3, 0xd3,
 602         0x44, 0x98, 0x79, 0x19, 0xd2, 0x48, 0x66, 0x2c, 0x91, 0x89, 0x64, 0xad, 0x2d, 0x2c, 0x2f, 0xdb,
 603         0x53, 0x7b, 0x68, 0xbf, 0xd6, 0x71, 0xd3, 0x27, 0xfd, 0xf5, 0x19, 0x8f, 0xe6, 0x22, 0x07, 0x75,
 604         0xc5, 0x8a, 0x45, 0xd2, 0x08, 0x9a, 0x65, 0x60, 0x38, 0xab, 0x0e, 0x96, 0x98, 0xb2, 0x3f, 0xb9,
 605         0x54, 0x99, 0x1b, 0x91, 0xc1, 0x81, 0xe1, 0xd9, 0xbf, 0x0c, 0xcd, 0xaf, 0x64, 0xfc, 0x77, 0xdf,
 606         0xc9, 0xd7, 0x01, 0x9e, 0xbc, 0x53, 0x42, 0x2a, 0x61, 0xae, 0x5e, 0xa6, 0x5c, 0x6b, 0xfb, 0x13,
 607         0x1e, 0x35, 0x5b, 0xc5, 0xdc, 0x70, 0x07, 0xb9, 0xc8, 0x1b, 0x9f, 0x3d, 0xa6, 0x7d, 0x25, 0xdb,
 608         0x70, 0x5a, 0x2c, 0x92, 0x46, 0xd0, 0xb4, 0xa1, 0x69, 0x35, 0xa3, 0x6f, 0xc3, 0xcf, 0x10, 0x99,
 609         0x37, 0x60, 0xb8, 0x6f, 0x2f, 0x6f, 0x8f, 0xad, 0xfa, 0xf6, 0x18, 0xf7, 0x5a, 0xb0, 0x4d, 0xb5,
 610         0x1f, 0xe1, 0x61, 0xc5, 0xd3, 0x12, 0x9c, 0x81, 0x8b, 0xbc, 0xa1, 0x3f, 0xe9, 0xe0, 0xe1, 0xfb,
 611         0x46, 0x0c, 0xd6, 0x33, 0xfb, 0x05, 0x9e, 0x24, 0xa9, 0x0c, 0x79, 0x7a, 0x0e, 0x97, 0xbc, 0x4c,
 612         0x8d, 0x73, 0xe4, 0x22, 0x6f, 0xe4, 0x3f, 0xec, 0xe0, 0xc9, 0xc5, 0xee, 0x30, 0xd8, 0x67, 0xed,
 613         0xa7, 0x78, 0x1c, 0x83, 0x8e, 0x94, 0x28, 0x8c, 0x90, 0xb9, 0x73, 0xc7, 0x45, 0xde, 0x5d, 0xff,
 614         0x41, 0x67, 0x1d, 0x9f, 0xf7, 0xa3, 0x60, 0x97, 0x3b, 0xf9, 0x8e, 0xf0, 0xfd, 0xbd, 0x32, 0x5e,
 615         0x0b, 0x6d, 0xec, 0x8f, 0x07, 0x85, 0xd0, 0xff, 0x2b, 0xa4, 0x71, 0xb7, 0x75, 0xdc, 0xeb, 0x6e,
 616         0x1e, 0x6d, 0x94, 0x9d, 0x32, 0x02, 0x3c, 0x14, 0x06, 0x32, 0xed, 0x0c, 0xdc, 0x23, 0x6f, 0x7c,
 617         0x76, 0x4a, 0xff, 0xfe, 0xfc, 0xe8, 0xde, 0x7e, 0x7d, 0x77, 0xaf, 0x9a, 0x8c, 0x60, 0x1d, 0xe5,
 618         0xd3, 0xe5, 0x8a, 0x58, 0xd7, 0x2b, 0x62, 0xdd, 0xac, 0x88, 0xf5, 0xa5, 0x26, 0x68, 0x59, 0x13,
 619         0x74, 0x5d, 0x13, 0x74, 0x53, 0x13, 0xf4, 0xa3, 0x26, 0xe8, 0xdb, 0x4f, 0x62, 0x7d, 0x18, 0x6d,
 620         0x32, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xab, 0x20, 0x12, 0x63, 0x3c, 0x03, 0x00, 0x00,
 621 }