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