cmd/bpa-operator/vendor/k8s.io/api/events/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/api/events/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/api/events/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 Event
  28                 EventList
  29                 EventSeries
  30 */
  31 package v1beta1
  32
  33 import proto "github.com/gogo/protobuf/proto"
  34 import fmt "fmt"
  35 import math "math"
  36
  37 import k8s_io_api_core_v1 "k8s.io/api/core/v1"
  38
  39 import strings "strings"
  40 import reflect "reflect"
  41
  42 import io "io"
  43
  44 // Reference imports to suppress errors if they are not otherwise used.
  45 var _ = proto.Marshal
  46 var _ = fmt.Errorf
  47 var _ = math.Inf
  48
  49 // This is a compile-time assertion to ensure that this generated file
  50 // is compatible with the proto package it is being compiled against.
  51 // A compilation error at this line likely means your copy of the
  52 // proto package needs to be updated.
  53 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  54
  55 func (m *Event) Reset()                    { *m = Event{} }
  56 func (*Event) ProtoMessage()               {}
  57 func (*Event) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  58
  59 func (m *EventList) Reset()                    { *m = EventList{} }
  60 func (*EventList) ProtoMessage()               {}
  61 func (*EventList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  62
  63 func (m *EventSeries) Reset()                    { *m = EventSeries{} }
  64 func (*EventSeries) ProtoMessage()               {}
  65 func (*EventSeries) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  66
  67 func init() {
  68         proto.RegisterType((*Event)(nil), "k8s.io.api.events.v1beta1.Event")
  69         proto.RegisterType((*EventList)(nil), "k8s.io.api.events.v1beta1.EventList")
  70         proto.RegisterType((*EventSeries)(nil), "k8s.io.api.events.v1beta1.EventSeries")
  71 }
  72 func (m *Event) 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 *Event) 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         dAtA[i] = 0x12
  96         i++
  97         i = encodeVarintGenerated(dAtA, i, uint64(m.EventTime.Size()))
  98         n2, err := m.EventTime.MarshalTo(dAtA[i:])
  99         if err != nil {
 100                 return 0, err
 101         }
 102         i += n2
 103         if m.Series != nil {
 104                 dAtA[i] = 0x1a
 105                 i++
 106                 i = encodeVarintGenerated(dAtA, i, uint64(m.Series.Size()))
 107                 n3, err := m.Series.MarshalTo(dAtA[i:])
 108                 if err != nil {
 109                         return 0, err
 110                 }
 111                 i += n3
 112         }
 113         dAtA[i] = 0x22
 114         i++
 115         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ReportingController)))
 116         i += copy(dAtA[i:], m.ReportingController)
 117         dAtA[i] = 0x2a
 118         i++
 119         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ReportingInstance)))
 120         i += copy(dAtA[i:], m.ReportingInstance)
 121         dAtA[i] = 0x32
 122         i++
 123         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Action)))
 124         i += copy(dAtA[i:], m.Action)
 125         dAtA[i] = 0x3a
 126         i++
 127         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 128         i += copy(dAtA[i:], m.Reason)
 129         dAtA[i] = 0x42
 130         i++
 131         i = encodeVarintGenerated(dAtA, i, uint64(m.Regarding.Size()))
 132         n4, err := m.Regarding.MarshalTo(dAtA[i:])
 133         if err != nil {
 134                 return 0, err
 135         }
 136         i += n4
 137         if m.Related != nil {
 138                 dAtA[i] = 0x4a
 139                 i++
 140                 i = encodeVarintGenerated(dAtA, i, uint64(m.Related.Size()))
 141                 n5, err := m.Related.MarshalTo(dAtA[i:])
 142                 if err != nil {
 143                         return 0, err
 144                 }
 145                 i += n5
 146         }
 147         dAtA[i] = 0x52
 148         i++
 149         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Note)))
 150         i += copy(dAtA[i:], m.Note)
 151         dAtA[i] = 0x5a
 152         i++
 153         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 154         i += copy(dAtA[i:], m.Type)
 155         dAtA[i] = 0x62
 156         i++
 157         i = encodeVarintGenerated(dAtA, i, uint64(m.DeprecatedSource.Size()))
 158         n6, err := m.DeprecatedSource.MarshalTo(dAtA[i:])
 159         if err != nil {
 160                 return 0, err
 161         }
 162         i += n6
 163         dAtA[i] = 0x6a
 164         i++
 165         i = encodeVarintGenerated(dAtA, i, uint64(m.DeprecatedFirstTimestamp.Size()))
 166         n7, err := m.DeprecatedFirstTimestamp.MarshalTo(dAtA[i:])
 167         if err != nil {
 168                 return 0, err
 169         }
 170         i += n7
 171         dAtA[i] = 0x72
 172         i++
 173         i = encodeVarintGenerated(dAtA, i, uint64(m.DeprecatedLastTimestamp.Size()))
 174         n8, err := m.DeprecatedLastTimestamp.MarshalTo(dAtA[i:])
 175         if err != nil {
 176                 return 0, err
 177         }
 178         i += n8
 179         dAtA[i] = 0x78
 180         i++
 181         i = encodeVarintGenerated(dAtA, i, uint64(m.DeprecatedCount))
 182         return i, nil
 183 }
 184
 185 func (m *EventList) Marshal() (dAtA []byte, err error) {
 186         size := m.Size()
 187         dAtA = make([]byte, size)
 188         n, err := m.MarshalTo(dAtA)
 189         if err != nil {
 190                 return nil, err
 191         }
 192         return dAtA[:n], nil
 193 }
 194
 195 func (m *EventList) MarshalTo(dAtA []byte) (int, error) {
 196         var i int
 197         _ = i
 198         var l int
 199         _ = l
 200         dAtA[i] = 0xa
 201         i++
 202         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 203         n9, err := m.ListMeta.MarshalTo(dAtA[i:])
 204         if err != nil {
 205                 return 0, err
 206         }
 207         i += n9
 208         if len(m.Items) > 0 {
 209                 for _, msg := range m.Items {
 210                         dAtA[i] = 0x12
 211                         i++
 212                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 213                         n, err := msg.MarshalTo(dAtA[i:])
 214                         if err != nil {
 215                                 return 0, err
 216                         }
 217                         i += n
 218                 }
 219         }
 220         return i, nil
 221 }
 222
 223 func (m *EventSeries) Marshal() (dAtA []byte, err error) {
 224         size := m.Size()
 225         dAtA = make([]byte, size)
 226         n, err := m.MarshalTo(dAtA)
 227         if err != nil {
 228                 return nil, err
 229         }
 230         return dAtA[:n], nil
 231 }
 232
 233 func (m *EventSeries) MarshalTo(dAtA []byte) (int, error) {
 234         var i int
 235         _ = i
 236         var l int
 237         _ = l
 238         dAtA[i] = 0x8
 239         i++
 240         i = encodeVarintGenerated(dAtA, i, uint64(m.Count))
 241         dAtA[i] = 0x12
 242         i++
 243         i = encodeVarintGenerated(dAtA, i, uint64(m.LastObservedTime.Size()))
 244         n10, err := m.LastObservedTime.MarshalTo(dAtA[i:])
 245         if err != nil {
 246                 return 0, err
 247         }
 248         i += n10
 249         dAtA[i] = 0x1a
 250         i++
 251         i = encodeVarintGenerated(dAtA, i, uint64(len(m.State)))
 252         i += copy(dAtA[i:], m.State)
 253         return i, nil
 254 }
 255
 256 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 257         for v >= 1<<7 {
 258                 dAtA[offset] = uint8(v&0x7f | 0x80)
 259                 v >>= 7
 260                 offset++
 261         }
 262         dAtA[offset] = uint8(v)
 263         return offset + 1
 264 }
 265 func (m *Event) Size() (n int) {
 266         var l int
 267         _ = l
 268         l = m.ObjectMeta.Size()
 269         n += 1 + l + sovGenerated(uint64(l))
 270         l = m.EventTime.Size()
 271         n += 1 + l + sovGenerated(uint64(l))
 272         if m.Series != nil {
 273                 l = m.Series.Size()
 274                 n += 1 + l + sovGenerated(uint64(l))
 275         }
 276         l = len(m.ReportingController)
 277         n += 1 + l + sovGenerated(uint64(l))
 278         l = len(m.ReportingInstance)
 279         n += 1 + l + sovGenerated(uint64(l))
 280         l = len(m.Action)
 281         n += 1 + l + sovGenerated(uint64(l))
 282         l = len(m.Reason)
 283         n += 1 + l + sovGenerated(uint64(l))
 284         l = m.Regarding.Size()
 285         n += 1 + l + sovGenerated(uint64(l))
 286         if m.Related != nil {
 287                 l = m.Related.Size()
 288                 n += 1 + l + sovGenerated(uint64(l))
 289         }
 290         l = len(m.Note)
 291         n += 1 + l + sovGenerated(uint64(l))
 292         l = len(m.Type)
 293         n += 1 + l + sovGenerated(uint64(l))
 294         l = m.DeprecatedSource.Size()
 295         n += 1 + l + sovGenerated(uint64(l))
 296         l = m.DeprecatedFirstTimestamp.Size()
 297         n += 1 + l + sovGenerated(uint64(l))
 298         l = m.DeprecatedLastTimestamp.Size()
 299         n += 1 + l + sovGenerated(uint64(l))
 300         n += 1 + sovGenerated(uint64(m.DeprecatedCount))
 301         return n
 302 }
 303
 304 func (m *EventList) Size() (n int) {
 305         var l int
 306         _ = l
 307         l = m.ListMeta.Size()
 308         n += 1 + l + sovGenerated(uint64(l))
 309         if len(m.Items) > 0 {
 310                 for _, e := range m.Items {
 311                         l = e.Size()
 312                         n += 1 + l + sovGenerated(uint64(l))
 313                 }
 314         }
 315         return n
 316 }
 317
 318 func (m *EventSeries) Size() (n int) {
 319         var l int
 320         _ = l
 321         n += 1 + sovGenerated(uint64(m.Count))
 322         l = m.LastObservedTime.Size()
 323         n += 1 + l + sovGenerated(uint64(l))
 324         l = len(m.State)
 325         n += 1 + l + sovGenerated(uint64(l))
 326         return n
 327 }
 328
 329 func sovGenerated(x uint64) (n int) {
 330         for {
 331                 n++
 332                 x >>= 7
 333                 if x == 0 {
 334                         break
 335                 }
 336         }
 337         return n
 338 }
 339 func sozGenerated(x uint64) (n int) {
 340         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 341 }
 342 func (this *Event) String() string {
 343         if this == nil {
 344                 return "nil"
 345         }
 346         s := strings.Join([]string{`&Event{`,
 347                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 348                 `EventTime:` + strings.Replace(strings.Replace(this.EventTime.String(), "MicroTime", "k8s_io_apimachinery_pkg_apis_meta_v1.MicroTime", 1), `&`, ``, 1) + `,`,
 349                 `Series:` + strings.Replace(fmt.Sprintf("%v", this.Series), "EventSeries", "EventSeries", 1) + `,`,
 350                 `ReportingController:` + fmt.Sprintf("%v", this.ReportingController) + `,`,
 351                 `ReportingInstance:` + fmt.Sprintf("%v", this.ReportingInstance) + `,`,
 352                 `Action:` + fmt.Sprintf("%v", this.Action) + `,`,
 353                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
 354                 `Regarding:` + strings.Replace(strings.Replace(this.Regarding.String(), "ObjectReference", "k8s_io_api_core_v1.ObjectReference", 1), `&`, ``, 1) + `,`,
 355                 `Related:` + strings.Replace(fmt.Sprintf("%v", this.Related), "ObjectReference", "k8s_io_api_core_v1.ObjectReference", 1) + `,`,
 356                 `Note:` + fmt.Sprintf("%v", this.Note) + `,`,
 357                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
 358                 `DeprecatedSource:` + strings.Replace(strings.Replace(this.DeprecatedSource.String(), "EventSource", "k8s_io_api_core_v1.EventSource", 1), `&`, ``, 1) + `,`,
 359                 `DeprecatedFirstTimestamp:` + strings.Replace(strings.Replace(this.DeprecatedFirstTimestamp.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
 360                 `DeprecatedLastTimestamp:` + strings.Replace(strings.Replace(this.DeprecatedLastTimestamp.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
 361                 `DeprecatedCount:` + fmt.Sprintf("%v", this.DeprecatedCount) + `,`,
 362                 `}`,
 363         }, "")
 364         return s
 365 }
 366 func (this *EventList) String() string {
 367         if this == nil {
 368                 return "nil"
 369         }
 370         s := strings.Join([]string{`&EventList{`,
 371                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 372                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Event", "Event", 1), `&`, ``, 1) + `,`,
 373                 `}`,
 374         }, "")
 375         return s
 376 }
 377 func (this *EventSeries) String() string {
 378         if this == nil {
 379                 return "nil"
 380         }
 381         s := strings.Join([]string{`&EventSeries{`,
 382                 `Count:` + fmt.Sprintf("%v", this.Count) + `,`,
 383                 `LastObservedTime:` + strings.Replace(strings.Replace(this.LastObservedTime.String(), "MicroTime", "k8s_io_apimachinery_pkg_apis_meta_v1.MicroTime", 1), `&`, ``, 1) + `,`,
 384                 `State:` + fmt.Sprintf("%v", this.State) + `,`,
 385                 `}`,
 386         }, "")
 387         return s
 388 }
 389 func valueToStringGenerated(v interface{}) string {
 390         rv := reflect.ValueOf(v)
 391         if rv.IsNil() {
 392                 return "nil"
 393         }
 394         pv := reflect.Indirect(rv).Interface()
 395         return fmt.Sprintf("*%v", pv)
 396 }
 397 func (m *Event) Unmarshal(dAtA []byte) error {
 398         l := len(dAtA)
 399         iNdEx := 0
 400         for iNdEx < l {
 401                 preIndex := iNdEx
 402                 var wire uint64
 403                 for shift := uint(0); ; shift += 7 {
 404                         if shift >= 64 {
 405                                 return ErrIntOverflowGenerated
 406                         }
 407                         if iNdEx >= l {
 408                                 return io.ErrUnexpectedEOF
 409                         }
 410                         b := dAtA[iNdEx]
 411                         iNdEx++
 412                         wire |= (uint64(b) & 0x7F) << shift
 413                         if b < 0x80 {
 414                                 break
 415                         }
 416                 }
 417                 fieldNum := int32(wire >> 3)
 418                 wireType := int(wire & 0x7)
 419                 if wireType == 4 {
 420                         return fmt.Errorf("proto: Event: wiretype end group for non-group")
 421                 }
 422                 if fieldNum <= 0 {
 423                         return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
 424                 }
 425                 switch fieldNum {
 426                 case 1:
 427                         if wireType != 2 {
 428                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 429                         }
 430                         var msglen int
 431                         for shift := uint(0); ; shift += 7 {
 432                                 if shift >= 64 {
 433                                         return ErrIntOverflowGenerated
 434                                 }
 435                                 if iNdEx >= l {
 436                                         return io.ErrUnexpectedEOF
 437                                 }
 438                                 b := dAtA[iNdEx]
 439                                 iNdEx++
 440                                 msglen |= (int(b) & 0x7F) << shift
 441                                 if b < 0x80 {
 442                                         break
 443                                 }
 444                         }
 445                         if msglen < 0 {
 446                                 return ErrInvalidLengthGenerated
 447                         }
 448                         postIndex := iNdEx + msglen
 449                         if postIndex > l {
 450                                 return io.ErrUnexpectedEOF
 451                         }
 452                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 453                                 return err
 454                         }
 455                         iNdEx = postIndex
 456                 case 2:
 457                         if wireType != 2 {
 458                                 return fmt.Errorf("proto: wrong wireType = %d for field EventTime", wireType)
 459                         }
 460                         var msglen int
 461                         for shift := uint(0); ; shift += 7 {
 462                                 if shift >= 64 {
 463                                         return ErrIntOverflowGenerated
 464                                 }
 465                                 if iNdEx >= l {
 466                                         return io.ErrUnexpectedEOF
 467                                 }
 468                                 b := dAtA[iNdEx]
 469                                 iNdEx++
 470                                 msglen |= (int(b) & 0x7F) << shift
 471                                 if b < 0x80 {
 472                                         break
 473                                 }
 474                         }
 475                         if msglen < 0 {
 476                                 return ErrInvalidLengthGenerated
 477                         }
 478                         postIndex := iNdEx + msglen
 479                         if postIndex > l {
 480                                 return io.ErrUnexpectedEOF
 481                         }
 482                         if err := m.EventTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 483                                 return err
 484                         }
 485                         iNdEx = postIndex
 486                 case 3:
 487                         if wireType != 2 {
 488                                 return fmt.Errorf("proto: wrong wireType = %d for field Series", wireType)
 489                         }
 490                         var msglen int
 491                         for shift := uint(0); ; shift += 7 {
 492                                 if shift >= 64 {
 493                                         return ErrIntOverflowGenerated
 494                                 }
 495                                 if iNdEx >= l {
 496                                         return io.ErrUnexpectedEOF
 497                                 }
 498                                 b := dAtA[iNdEx]
 499                                 iNdEx++
 500                                 msglen |= (int(b) & 0x7F) << shift
 501                                 if b < 0x80 {
 502                                         break
 503                                 }
 504                         }
 505                         if msglen < 0 {
 506                                 return ErrInvalidLengthGenerated
 507                         }
 508                         postIndex := iNdEx + msglen
 509                         if postIndex > l {
 510                                 return io.ErrUnexpectedEOF
 511                         }
 512                         if m.Series == nil {
 513                                 m.Series = &EventSeries{}
 514                         }
 515                         if err := m.Series.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 516                                 return err
 517                         }
 518                         iNdEx = postIndex
 519                 case 4:
 520                         if wireType != 2 {
 521                                 return fmt.Errorf("proto: wrong wireType = %d for field ReportingController", wireType)
 522                         }
 523                         var stringLen uint64
 524                         for shift := uint(0); ; shift += 7 {
 525                                 if shift >= 64 {
 526                                         return ErrIntOverflowGenerated
 527                                 }
 528                                 if iNdEx >= l {
 529                                         return io.ErrUnexpectedEOF
 530                                 }
 531                                 b := dAtA[iNdEx]
 532                                 iNdEx++
 533                                 stringLen |= (uint64(b) & 0x7F) << shift
 534                                 if b < 0x80 {
 535                                         break
 536                                 }
 537                         }
 538                         intStringLen := int(stringLen)
 539                         if intStringLen < 0 {
 540                                 return ErrInvalidLengthGenerated
 541                         }
 542                         postIndex := iNdEx + intStringLen
 543                         if postIndex > l {
 544                                 return io.ErrUnexpectedEOF
 545                         }
 546                         m.ReportingController = string(dAtA[iNdEx:postIndex])
 547                         iNdEx = postIndex
 548                 case 5:
 549                         if wireType != 2 {
 550                                 return fmt.Errorf("proto: wrong wireType = %d for field ReportingInstance", wireType)
 551                         }
 552                         var stringLen uint64
 553                         for shift := uint(0); ; shift += 7 {
 554                                 if shift >= 64 {
 555                                         return ErrIntOverflowGenerated
 556                                 }
 557                                 if iNdEx >= l {
 558                                         return io.ErrUnexpectedEOF
 559                                 }
 560                                 b := dAtA[iNdEx]
 561                                 iNdEx++
 562                                 stringLen |= (uint64(b) & 0x7F) << shift
 563                                 if b < 0x80 {
 564                                         break
 565                                 }
 566                         }
 567                         intStringLen := int(stringLen)
 568                         if intStringLen < 0 {
 569                                 return ErrInvalidLengthGenerated
 570                         }
 571                         postIndex := iNdEx + intStringLen
 572                         if postIndex > l {
 573                                 return io.ErrUnexpectedEOF
 574                         }
 575                         m.ReportingInstance = string(dAtA[iNdEx:postIndex])
 576                         iNdEx = postIndex
 577                 case 6:
 578                         if wireType != 2 {
 579                                 return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
 580                         }
 581                         var stringLen uint64
 582                         for shift := uint(0); ; shift += 7 {
 583                                 if shift >= 64 {
 584                                         return ErrIntOverflowGenerated
 585                                 }
 586                                 if iNdEx >= l {
 587                                         return io.ErrUnexpectedEOF
 588                                 }
 589                                 b := dAtA[iNdEx]
 590                                 iNdEx++
 591                                 stringLen |= (uint64(b) & 0x7F) << shift
 592                                 if b < 0x80 {
 593                                         break
 594                                 }
 595                         }
 596                         intStringLen := int(stringLen)
 597                         if intStringLen < 0 {
 598                                 return ErrInvalidLengthGenerated
 599                         }
 600                         postIndex := iNdEx + intStringLen
 601                         if postIndex > l {
 602                                 return io.ErrUnexpectedEOF
 603                         }
 604                         m.Action = string(dAtA[iNdEx:postIndex])
 605                         iNdEx = postIndex
 606                 case 7:
 607                         if wireType != 2 {
 608                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
 609                         }
 610                         var stringLen uint64
 611                         for shift := uint(0); ; shift += 7 {
 612                                 if shift >= 64 {
 613                                         return ErrIntOverflowGenerated
 614                                 }
 615                                 if iNdEx >= l {
 616                                         return io.ErrUnexpectedEOF
 617                                 }
 618                                 b := dAtA[iNdEx]
 619                                 iNdEx++
 620                                 stringLen |= (uint64(b) & 0x7F) << shift
 621                                 if b < 0x80 {
 622                                         break
 623                                 }
 624                         }
 625                         intStringLen := int(stringLen)
 626                         if intStringLen < 0 {
 627                                 return ErrInvalidLengthGenerated
 628                         }
 629                         postIndex := iNdEx + intStringLen
 630                         if postIndex > l {
 631                                 return io.ErrUnexpectedEOF
 632                         }
 633                         m.Reason = string(dAtA[iNdEx:postIndex])
 634                         iNdEx = postIndex
 635                 case 8:
 636                         if wireType != 2 {
 637                                 return fmt.Errorf("proto: wrong wireType = %d for field Regarding", wireType)
 638                         }
 639                         var msglen int
 640                         for shift := uint(0); ; shift += 7 {
 641                                 if shift >= 64 {
 642                                         return ErrIntOverflowGenerated
 643                                 }
 644                                 if iNdEx >= l {
 645                                         return io.ErrUnexpectedEOF
 646                                 }
 647                                 b := dAtA[iNdEx]
 648                                 iNdEx++
 649                                 msglen |= (int(b) & 0x7F) << shift
 650                                 if b < 0x80 {
 651                                         break
 652                                 }
 653                         }
 654                         if msglen < 0 {
 655                                 return ErrInvalidLengthGenerated
 656                         }
 657                         postIndex := iNdEx + msglen
 658                         if postIndex > l {
 659                                 return io.ErrUnexpectedEOF
 660                         }
 661                         if err := m.Regarding.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 662                                 return err
 663                         }
 664                         iNdEx = postIndex
 665                 case 9:
 666                         if wireType != 2 {
 667                                 return fmt.Errorf("proto: wrong wireType = %d for field Related", wireType)
 668                         }
 669                         var msglen int
 670                         for shift := uint(0); ; shift += 7 {
 671                                 if shift >= 64 {
 672                                         return ErrIntOverflowGenerated
 673                                 }
 674                                 if iNdEx >= l {
 675                                         return io.ErrUnexpectedEOF
 676                                 }
 677                                 b := dAtA[iNdEx]
 678                                 iNdEx++
 679                                 msglen |= (int(b) & 0x7F) << shift
 680                                 if b < 0x80 {
 681                                         break
 682                                 }
 683                         }
 684                         if msglen < 0 {
 685                                 return ErrInvalidLengthGenerated
 686                         }
 687                         postIndex := iNdEx + msglen
 688                         if postIndex > l {
 689                                 return io.ErrUnexpectedEOF
 690                         }
 691                         if m.Related == nil {
 692                                 m.Related = &k8s_io_api_core_v1.ObjectReference{}
 693                         }
 694                         if err := m.Related.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 695                                 return err
 696                         }
 697                         iNdEx = postIndex
 698                 case 10:
 699                         if wireType != 2 {
 700                                 return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType)
 701                         }
 702                         var stringLen uint64
 703                         for shift := uint(0); ; shift += 7 {
 704                                 if shift >= 64 {
 705                                         return ErrIntOverflowGenerated
 706                                 }
 707                                 if iNdEx >= l {
 708                                         return io.ErrUnexpectedEOF
 709                                 }
 710                                 b := dAtA[iNdEx]
 711                                 iNdEx++
 712                                 stringLen |= (uint64(b) & 0x7F) << shift
 713                                 if b < 0x80 {
 714                                         break
 715                                 }
 716                         }
 717                         intStringLen := int(stringLen)
 718                         if intStringLen < 0 {
 719                                 return ErrInvalidLengthGenerated
 720                         }
 721                         postIndex := iNdEx + intStringLen
 722                         if postIndex > l {
 723                                 return io.ErrUnexpectedEOF
 724                         }
 725                         m.Note = string(dAtA[iNdEx:postIndex])
 726                         iNdEx = postIndex
 727                 case 11:
 728                         if wireType != 2 {
 729                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
 730                         }
 731                         var stringLen uint64
 732                         for shift := uint(0); ; shift += 7 {
 733                                 if shift >= 64 {
 734                                         return ErrIntOverflowGenerated
 735                                 }
 736                                 if iNdEx >= l {
 737                                         return io.ErrUnexpectedEOF
 738                                 }
 739                                 b := dAtA[iNdEx]
 740                                 iNdEx++
 741                                 stringLen |= (uint64(b) & 0x7F) << shift
 742                                 if b < 0x80 {
 743                                         break
 744                                 }
 745                         }
 746                         intStringLen := int(stringLen)
 747                         if intStringLen < 0 {
 748                                 return ErrInvalidLengthGenerated
 749                         }
 750                         postIndex := iNdEx + intStringLen
 751                         if postIndex > l {
 752                                 return io.ErrUnexpectedEOF
 753                         }
 754                         m.Type = string(dAtA[iNdEx:postIndex])
 755                         iNdEx = postIndex
 756                 case 12:
 757                         if wireType != 2 {
 758                                 return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedSource", wireType)
 759                         }
 760                         var msglen int
 761                         for shift := uint(0); ; shift += 7 {
 762                                 if shift >= 64 {
 763                                         return ErrIntOverflowGenerated
 764                                 }
 765                                 if iNdEx >= l {
 766                                         return io.ErrUnexpectedEOF
 767                                 }
 768                                 b := dAtA[iNdEx]
 769                                 iNdEx++
 770                                 msglen |= (int(b) & 0x7F) << shift
 771                                 if b < 0x80 {
 772                                         break
 773                                 }
 774                         }
 775                         if msglen < 0 {
 776                                 return ErrInvalidLengthGenerated
 777                         }
 778                         postIndex := iNdEx + msglen
 779                         if postIndex > l {
 780                                 return io.ErrUnexpectedEOF
 781                         }
 782                         if err := m.DeprecatedSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 783                                 return err
 784                         }
 785                         iNdEx = postIndex
 786                 case 13:
 787                         if wireType != 2 {
 788                                 return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedFirstTimestamp", wireType)
 789                         }
 790                         var msglen int
 791                         for shift := uint(0); ; shift += 7 {
 792                                 if shift >= 64 {
 793                                         return ErrIntOverflowGenerated
 794                                 }
 795                                 if iNdEx >= l {
 796                                         return io.ErrUnexpectedEOF
 797                                 }
 798                                 b := dAtA[iNdEx]
 799                                 iNdEx++
 800                                 msglen |= (int(b) & 0x7F) << shift
 801                                 if b < 0x80 {
 802                                         break
 803                                 }
 804                         }
 805                         if msglen < 0 {
 806                                 return ErrInvalidLengthGenerated
 807                         }
 808                         postIndex := iNdEx + msglen
 809                         if postIndex > l {
 810                                 return io.ErrUnexpectedEOF
 811                         }
 812                         if err := m.DeprecatedFirstTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 813                                 return err
 814                         }
 815                         iNdEx = postIndex
 816                 case 14:
 817                         if wireType != 2 {
 818                                 return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedLastTimestamp", wireType)
 819                         }
 820                         var msglen int
 821                         for shift := uint(0); ; shift += 7 {
 822                                 if shift >= 64 {
 823                                         return ErrIntOverflowGenerated
 824                                 }
 825                                 if iNdEx >= l {
 826                                         return io.ErrUnexpectedEOF
 827                                 }
 828                                 b := dAtA[iNdEx]
 829                                 iNdEx++
 830                                 msglen |= (int(b) & 0x7F) << shift
 831                                 if b < 0x80 {
 832                                         break
 833                                 }
 834                         }
 835                         if msglen < 0 {
 836                                 return ErrInvalidLengthGenerated
 837                         }
 838                         postIndex := iNdEx + msglen
 839                         if postIndex > l {
 840                                 return io.ErrUnexpectedEOF
 841                         }
 842                         if err := m.DeprecatedLastTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 843                                 return err
 844                         }
 845                         iNdEx = postIndex
 846                 case 15:
 847                         if wireType != 0 {
 848                                 return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedCount", wireType)
 849                         }
 850                         m.DeprecatedCount = 0
 851                         for shift := uint(0); ; shift += 7 {
 852                                 if shift >= 64 {
 853                                         return ErrIntOverflowGenerated
 854                                 }
 855                                 if iNdEx >= l {
 856                                         return io.ErrUnexpectedEOF
 857                                 }
 858                                 b := dAtA[iNdEx]
 859                                 iNdEx++
 860                                 m.DeprecatedCount |= (int32(b) & 0x7F) << shift
 861                                 if b < 0x80 {
 862                                         break
 863                                 }
 864                         }
 865                 default:
 866                         iNdEx = preIndex
 867                         skippy, err := skipGenerated(dAtA[iNdEx:])
 868                         if err != nil {
 869                                 return err
 870                         }
 871                         if skippy < 0 {
 872                                 return ErrInvalidLengthGenerated
 873                         }
 874                         if (iNdEx + skippy) > l {
 875                                 return io.ErrUnexpectedEOF
 876                         }
 877                         iNdEx += skippy
 878                 }
 879         }
 880
 881         if iNdEx > l {
 882                 return io.ErrUnexpectedEOF
 883         }
 884         return nil
 885 }
 886 func (m *EventList) Unmarshal(dAtA []byte) error {
 887         l := len(dAtA)
 888         iNdEx := 0
 889         for iNdEx < l {
 890                 preIndex := iNdEx
 891                 var wire uint64
 892                 for shift := uint(0); ; shift += 7 {
 893                         if shift >= 64 {
 894                                 return ErrIntOverflowGenerated
 895                         }
 896                         if iNdEx >= l {
 897                                 return io.ErrUnexpectedEOF
 898                         }
 899                         b := dAtA[iNdEx]
 900                         iNdEx++
 901                         wire |= (uint64(b) & 0x7F) << shift
 902                         if b < 0x80 {
 903                                 break
 904                         }
 905                 }
 906                 fieldNum := int32(wire >> 3)
 907                 wireType := int(wire & 0x7)
 908                 if wireType == 4 {
 909                         return fmt.Errorf("proto: EventList: wiretype end group for non-group")
 910                 }
 911                 if fieldNum <= 0 {
 912                         return fmt.Errorf("proto: EventList: illegal tag %d (wire type %d)", fieldNum, wire)
 913                 }
 914                 switch fieldNum {
 915                 case 1:
 916                         if wireType != 2 {
 917                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 918                         }
 919                         var msglen int
 920                         for shift := uint(0); ; shift += 7 {
 921                                 if shift >= 64 {
 922                                         return ErrIntOverflowGenerated
 923                                 }
 924                                 if iNdEx >= l {
 925                                         return io.ErrUnexpectedEOF
 926                                 }
 927                                 b := dAtA[iNdEx]
 928                                 iNdEx++
 929                                 msglen |= (int(b) & 0x7F) << shift
 930                                 if b < 0x80 {
 931                                         break
 932                                 }
 933                         }
 934                         if msglen < 0 {
 935                                 return ErrInvalidLengthGenerated
 936                         }
 937                         postIndex := iNdEx + msglen
 938                         if postIndex > l {
 939                                 return io.ErrUnexpectedEOF
 940                         }
 941                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 942                                 return err
 943                         }
 944                         iNdEx = postIndex
 945                 case 2:
 946                         if wireType != 2 {
 947                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 948                         }
 949                         var msglen int
 950                         for shift := uint(0); ; shift += 7 {
 951                                 if shift >= 64 {
 952                                         return ErrIntOverflowGenerated
 953                                 }
 954                                 if iNdEx >= l {
 955                                         return io.ErrUnexpectedEOF
 956                                 }
 957                                 b := dAtA[iNdEx]
 958                                 iNdEx++
 959                                 msglen |= (int(b) & 0x7F) << shift
 960                                 if b < 0x80 {
 961                                         break
 962                                 }
 963                         }
 964                         if msglen < 0 {
 965                                 return ErrInvalidLengthGenerated
 966                         }
 967                         postIndex := iNdEx + msglen
 968                         if postIndex > l {
 969                                 return io.ErrUnexpectedEOF
 970                         }
 971                         m.Items = append(m.Items, Event{})
 972                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 973                                 return err
 974                         }
 975                         iNdEx = postIndex
 976                 default:
 977                         iNdEx = preIndex
 978                         skippy, err := skipGenerated(dAtA[iNdEx:])
 979                         if err != nil {
 980                                 return err
 981                         }
 982                         if skippy < 0 {
 983                                 return ErrInvalidLengthGenerated
 984                         }
 985                         if (iNdEx + skippy) > l {
 986                                 return io.ErrUnexpectedEOF
 987                         }
 988                         iNdEx += skippy
 989                 }
 990         }
 991
 992         if iNdEx > l {
 993                 return io.ErrUnexpectedEOF
 994         }
 995         return nil
 996 }
 997 func (m *EventSeries) Unmarshal(dAtA []byte) error {
 998         l := len(dAtA)
 999         iNdEx := 0
1000         for iNdEx < l {
1001                 preIndex := iNdEx
1002                 var wire uint64
1003                 for shift := uint(0); ; shift += 7 {
1004                         if shift >= 64 {
1005                                 return ErrIntOverflowGenerated
1006                         }
1007                         if iNdEx >= l {
1008                                 return io.ErrUnexpectedEOF
1009                         }
1010                         b := dAtA[iNdEx]
1011                         iNdEx++
1012                         wire |= (uint64(b) & 0x7F) << shift
1013                         if b < 0x80 {
1014                                 break
1015                         }
1016                 }
1017                 fieldNum := int32(wire >> 3)
1018                 wireType := int(wire & 0x7)
1019                 if wireType == 4 {
1020                         return fmt.Errorf("proto: EventSeries: wiretype end group for non-group")
1021                 }
1022                 if fieldNum <= 0 {
1023                         return fmt.Errorf("proto: EventSeries: illegal tag %d (wire type %d)", fieldNum, wire)
1024                 }
1025                 switch fieldNum {
1026                 case 1:
1027                         if wireType != 0 {
1028                                 return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
1029                         }
1030                         m.Count = 0
1031                         for shift := uint(0); ; shift += 7 {
1032                                 if shift >= 64 {
1033                                         return ErrIntOverflowGenerated
1034                                 }
1035                                 if iNdEx >= l {
1036                                         return io.ErrUnexpectedEOF
1037                                 }
1038                                 b := dAtA[iNdEx]
1039                                 iNdEx++
1040                                 m.Count |= (int32(b) & 0x7F) << shift
1041                                 if b < 0x80 {
1042                                         break
1043                                 }
1044                         }
1045                 case 2:
1046                         if wireType != 2 {
1047                                 return fmt.Errorf("proto: wrong wireType = %d for field LastObservedTime", wireType)
1048                         }
1049                         var msglen int
1050                         for shift := uint(0); ; shift += 7 {
1051                                 if shift >= 64 {
1052                                         return ErrIntOverflowGenerated
1053                                 }
1054                                 if iNdEx >= l {
1055                                         return io.ErrUnexpectedEOF
1056                                 }
1057                                 b := dAtA[iNdEx]
1058                                 iNdEx++
1059                                 msglen |= (int(b) & 0x7F) << shift
1060                                 if b < 0x80 {
1061                                         break
1062                                 }
1063                         }
1064                         if msglen < 0 {
1065                                 return ErrInvalidLengthGenerated
1066                         }
1067                         postIndex := iNdEx + msglen
1068                         if postIndex > l {
1069                                 return io.ErrUnexpectedEOF
1070                         }
1071                         if err := m.LastObservedTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1072                                 return err
1073                         }
1074                         iNdEx = postIndex
1075                 case 3:
1076                         if wireType != 2 {
1077                                 return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
1078                         }
1079                         var stringLen uint64
1080                         for shift := uint(0); ; shift += 7 {
1081                                 if shift >= 64 {
1082                                         return ErrIntOverflowGenerated
1083                                 }
1084                                 if iNdEx >= l {
1085                                         return io.ErrUnexpectedEOF
1086                                 }
1087                                 b := dAtA[iNdEx]
1088                                 iNdEx++
1089                                 stringLen |= (uint64(b) & 0x7F) << shift
1090                                 if b < 0x80 {
1091                                         break
1092                                 }
1093                         }
1094                         intStringLen := int(stringLen)
1095                         if intStringLen < 0 {
1096                                 return ErrInvalidLengthGenerated
1097                         }
1098                         postIndex := iNdEx + intStringLen
1099                         if postIndex > l {
1100                                 return io.ErrUnexpectedEOF
1101                         }
1102                         m.State = EventSeriesState(dAtA[iNdEx:postIndex])
1103                         iNdEx = postIndex
1104                 default:
1105                         iNdEx = preIndex
1106                         skippy, err := skipGenerated(dAtA[iNdEx:])
1107                         if err != nil {
1108                                 return err
1109                         }
1110                         if skippy < 0 {
1111                                 return ErrInvalidLengthGenerated
1112                         }
1113                         if (iNdEx + skippy) > l {
1114                                 return io.ErrUnexpectedEOF
1115                         }
1116                         iNdEx += skippy
1117                 }
1118         }
1119
1120         if iNdEx > l {
1121                 return io.ErrUnexpectedEOF
1122         }
1123         return nil
1124 }
1125 func skipGenerated(dAtA []byte) (n int, err error) {
1126         l := len(dAtA)
1127         iNdEx := 0
1128         for iNdEx < l {
1129                 var wire uint64
1130                 for shift := uint(0); ; shift += 7 {
1131                         if shift >= 64 {
1132                                 return 0, ErrIntOverflowGenerated
1133                         }
1134                         if iNdEx >= l {
1135                                 return 0, io.ErrUnexpectedEOF
1136                         }
1137                         b := dAtA[iNdEx]
1138                         iNdEx++
1139                         wire |= (uint64(b) & 0x7F) << shift
1140                         if b < 0x80 {
1141                                 break
1142                         }
1143                 }
1144                 wireType := int(wire & 0x7)
1145                 switch wireType {
1146                 case 0:
1147                         for shift := uint(0); ; shift += 7 {
1148                                 if shift >= 64 {
1149                                         return 0, ErrIntOverflowGenerated
1150                                 }
1151                                 if iNdEx >= l {
1152                                         return 0, io.ErrUnexpectedEOF
1153                                 }
1154                                 iNdEx++
1155                                 if dAtA[iNdEx-1] < 0x80 {
1156                                         break
1157                                 }
1158                         }
1159                         return iNdEx, nil
1160                 case 1:
1161                         iNdEx += 8
1162                         return iNdEx, nil
1163                 case 2:
1164                         var length int
1165                         for shift := uint(0); ; shift += 7 {
1166                                 if shift >= 64 {
1167                                         return 0, ErrIntOverflowGenerated
1168                                 }
1169                                 if iNdEx >= l {
1170                                         return 0, io.ErrUnexpectedEOF
1171                                 }
1172                                 b := dAtA[iNdEx]
1173                                 iNdEx++
1174                                 length |= (int(b) & 0x7F) << shift
1175                                 if b < 0x80 {
1176                                         break
1177                                 }
1178                         }
1179                         iNdEx += length
1180                         if length < 0 {
1181                                 return 0, ErrInvalidLengthGenerated
1182                         }
1183                         return iNdEx, nil
1184                 case 3:
1185                         for {
1186                                 var innerWire uint64
1187                                 var start int = iNdEx
1188                                 for shift := uint(0); ; shift += 7 {
1189                                         if shift >= 64 {
1190                                                 return 0, ErrIntOverflowGenerated
1191                                         }
1192                                         if iNdEx >= l {
1193                                                 return 0, io.ErrUnexpectedEOF
1194                                         }
1195                                         b := dAtA[iNdEx]
1196                                         iNdEx++
1197                                         innerWire |= (uint64(b) & 0x7F) << shift
1198                                         if b < 0x80 {
1199                                                 break
1200                                         }
1201                                 }
1202                                 innerWireType := int(innerWire & 0x7)
1203                                 if innerWireType == 4 {
1204                                         break
1205                                 }
1206                                 next, err := skipGenerated(dAtA[start:])
1207                                 if err != nil {
1208                                         return 0, err
1209                                 }
1210                                 iNdEx = start + next
1211                         }
1212                         return iNdEx, nil
1213                 case 4:
1214                         return iNdEx, nil
1215                 case 5:
1216                         iNdEx += 4
1217                         return iNdEx, nil
1218                 default:
1219                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1220                 }
1221         }
1222         panic("unreachable")
1223 }
1224
1225 var (
1226         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1227         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
1228 )
1229
1230 func init() {
1231         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/events/v1beta1/generated.proto", fileDescriptorGenerated)
1232 }
1233
1234 var fileDescriptorGenerated = []byte{
1235         // 801 bytes of a gzipped FileDescriptorProto
1236         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xcd, 0x6e, 0xdb, 0x46,
1237         0x10, 0x16, 0x13, 0x4b, 0xb2, 0x56, 0x49, 0x2c, 0x6f, 0x0e, 0xde, 0xb8, 0x00, 0xa5, 0x2a, 0x40,
1238         0x20, 0x14, 0x08, 0x59, 0x07, 0x45, 0xdb, 0x6b, 0x18, 0xb9, 0x45, 0x02, 0xbb, 0x01, 0xd6, 0x3e,
1239         0x15, 0x3d, 0x64, 0x45, 0x4d, 0x68, 0x56, 0xe2, 0x2e, 0xb1, 0xbb, 0x12, 0xe0, 0x5b, 0x2f, 0x05,
1240         0x7a, 0xec, 0x33, 0xf4, 0x09, 0xfa, 0x18, 0x3e, 0xe6, 0x98, 0x93, 0x50, 0xb3, 0x6f, 0xd1, 0x53,
1241         0xc1, 0xe5, 0x4a, 0x94, 0xf5, 0x83, 0xa8, 0xe8, 0x4d, 0x9c, 0xf9, 0x7e, 0x66, 0x66, 0x47, 0x83,
1242         0x82, 0xd1, 0xb7, 0xca, 0x8b, 0x85, 0x3f, 0x9a, 0x0c, 0x40, 0x72, 0xd0, 0xa0, 0xfc, 0x29, 0xf0,
1243         0xa1, 0x90, 0xbe, 0x4d, 0xb0, 0x34, 0xf6, 0x61, 0x0a, 0x5c, 0x2b, 0x7f, 0x7a, 0x32, 0x00, 0xcd,
1244         0x4e, 0xfc, 0x08, 0x38, 0x48, 0xa6, 0x61, 0xe8, 0xa5, 0x52, 0x68, 0x81, 0x9f, 0x14, 0x50, 0x8f,
1245         0xa5, 0xb1, 0x57, 0x40, 0x3d, 0x0b, 0x3d, 0x7e, 0x1e, 0xc5, 0xfa, 0x6a, 0x32, 0xf0, 0x42, 0x91,
1246         0xf8, 0x91, 0x88, 0x84, 0x6f, 0x18, 0x83, 0xc9, 0x7b, 0xf3, 0x65, 0x3e, 0xcc, 0xaf, 0x42, 0xe9,
1247         0xb8, 0xbb, 0x64, 0x1a, 0x0a, 0x09, 0xfe, 0x74, 0xcd, 0xed, 0xf8, 0xab, 0x12, 0x93, 0xb0, 0xf0,
1248         0x2a, 0xe6, 0x20, 0xaf, 0xfd, 0x74, 0x14, 0xe5, 0x01, 0xe5, 0x27, 0xa0, 0xd9, 0x26, 0x96, 0xbf,
1249         0x8d, 0x25, 0x27, 0x5c, 0xc7, 0x09, 0xac, 0x11, 0xbe, 0xfe, 0x14, 0x41, 0x85, 0x57, 0x90, 0xb0,
1250         0x55, 0x5e, 0xf7, 0x8f, 0x06, 0xaa, 0x9e, 0xe6, 0x43, 0xc0, 0xef, 0xd0, 0x7e, 0x5e, 0xcd, 0x90,
1251         0x69, 0x46, 0x9c, 0x8e, 0xd3, 0x6b, 0xbe, 0xf8, 0xd2, 0x2b, 0x27, 0xb5, 0x10, 0xf5, 0xd2, 0x51,
1252         0x94, 0x07, 0x94, 0x97, 0xa3, 0xbd, 0xe9, 0x89, 0xf7, 0x76, 0xf0, 0x33, 0x84, 0xfa, 0x1c, 0x34,
1253         0x0b, 0xf0, 0xcd, 0xac, 0x5d, 0xc9, 0x66, 0x6d, 0x54, 0xc6, 0xe8, 0x42, 0x15, 0xbf, 0x43, 0x0d,
1254         0x33, 0xef, 0xcb, 0x38, 0x01, 0x72, 0xcf, 0x58, 0xf8, 0xbb, 0x59, 0x9c, 0xc7, 0xa1, 0x14, 0x39,
1255         0x2d, 0x38, 0xb4, 0x0e, 0x8d, 0xd3, 0xb9, 0x12, 0x2d, 0x45, 0xf1, 0x1b, 0x54, 0x53, 0x20, 0x63,
1256         0x50, 0xe4, 0xbe, 0x91, 0x7f, 0xe6, 0x6d, 0x7d, 0x6b, 0xcf, 0x08, 0x5c, 0x18, 0x74, 0x80, 0xb2,
1257         0x59, 0xbb, 0x56, 0xfc, 0xa6, 0x56, 0x01, 0x9f, 0xa3, 0xc7, 0x12, 0x52, 0x21, 0x75, 0xcc, 0xa3,
1258         0x57, 0x82, 0x6b, 0x29, 0xc6, 0x63, 0x90, 0x64, 0xaf, 0xe3, 0xf4, 0x1a, 0xc1, 0x67, 0xb6, 0x8c,
1259         0xc7, 0x74, 0x1d, 0x42, 0x37, 0xf1, 0xf0, 0xf7, 0xe8, 0x70, 0x11, 0x7e, 0xcd, 0x95, 0x66, 0x3c,
1260         0x04, 0x52, 0x35, 0x62, 0x4f, 0xac, 0xd8, 0x21, 0x5d, 0x05, 0xd0, 0x75, 0x0e, 0x7e, 0x86, 0x6a,
1261         0x2c, 0xd4, 0xb1, 0xe0, 0xa4, 0x66, 0xd8, 0x8f, 0x2c, 0xbb, 0xf6, 0xd2, 0x44, 0xa9, 0xcd, 0xe6,
1262         0x38, 0x09, 0x4c, 0x09, 0x4e, 0xea, 0x77, 0x71, 0xd4, 0x44, 0xa9, 0xcd, 0xe2, 0x4b, 0xd4, 0x90,
1263         0x10, 0x31, 0x39, 0x8c, 0x79, 0x44, 0xf6, 0xcd, 0xd8, 0x9e, 0x2e, 0x8f, 0x2d, 0x5f, 0xec, 0xf2,
1264         0x99, 0x29, 0xbc, 0x07, 0x09, 0x3c, 0x5c, 0x7a, 0x09, 0x3a, 0x67, 0xd3, 0x52, 0x08, 0xbf, 0x41,
1265         0x75, 0x09, 0xe3, 0x7c, 0xd1, 0x48, 0x63, 0x77, 0xcd, 0x66, 0x36, 0x6b, 0xd7, 0x69, 0xc1, 0xa3,
1266         0x73, 0x01, 0xdc, 0x41, 0x7b, 0x5c, 0x68, 0x20, 0xc8, 0xf4, 0xf1, 0xc0, 0xfa, 0xee, 0xfd, 0x20,
1267         0x34, 0x50, 0x93, 0xc9, 0x11, 0xfa, 0x3a, 0x05, 0xd2, 0xbc, 0x8b, 0xb8, 0xbc, 0x4e, 0x81, 0x9a,
1268         0x0c, 0x06, 0xd4, 0x1a, 0x42, 0x2a, 0x21, 0xcc, 0x15, 0x2f, 0xc4, 0x44, 0x86, 0x40, 0x1e, 0x98,
1269         0xc2, 0xda, 0x9b, 0x0a, 0x2b, 0x96, 0xc3, 0xc0, 0x02, 0x62, 0xe5, 0x5a, 0xfd, 0x15, 0x01, 0xba,
1270         0x26, 0x89, 0x7f, 0x73, 0x10, 0x29, 0x83, 0xdf, 0xc5, 0x52, 0x99, 0xc5, 0x54, 0x9a, 0x25, 0x29,
1271         0x79, 0x68, 0xfc, 0xbe, 0xd8, 0x6d, 0xe5, 0xcd, 0xb6, 0x77, 0xac, 0x35, 0xe9, 0x6f, 0xd1, 0xa4,
1272         0x5b, 0xdd, 0xf0, 0xaf, 0x0e, 0x3a, 0x2a, 0x93, 0x67, 0x6c, 0xb9, 0x92, 0x47, 0xff, 0xb9, 0x92,
1273         0xb6, 0xad, 0xe4, 0xa8, 0xbf, 0x59, 0x92, 0x6e, 0xf3, 0xc2, 0x2f, 0xd1, 0x41, 0x99, 0x7a, 0x25,
1274         0x26, 0x5c, 0x93, 0x83, 0x8e, 0xd3, 0xab, 0x06, 0x47, 0x56, 0xf2, 0xa0, 0x7f, 0x37, 0x4d, 0x57,
1275         0xf1, 0xdd, 0x3f, 0x1d, 0x54, 0xfc, 0xdf, 0xcf, 0x62, 0xa5, 0xf1, 0x4f, 0x6b, 0x87, 0xca, 0xdb,
1276         0xad, 0x91, 0x9c, 0x6d, 0xce, 0x54, 0xcb, 0x3a, 0xef, 0xcf, 0x23, 0x4b, 0x47, 0xea, 0x14, 0x55,
1277         0x63, 0x0d, 0x89, 0x22, 0xf7, 0x3a, 0xf7, 0x7b, 0xcd, 0x17, 0x9d, 0x4f, 0x5d, 0x90, 0xe0, 0xa1,
1278         0x15, 0xab, 0xbe, 0xce, 0x69, 0xb4, 0x60, 0x77, 0x33, 0x07, 0x35, 0x97, 0x2e, 0x0c, 0x7e, 0x8a,
1279         0xaa, 0xa1, 0xe9, 0xdd, 0x31, 0xbd, 0x2f, 0x48, 0x45, 0xc7, 0x45, 0x0e, 0x4f, 0x50, 0x6b, 0xcc,
1280         0x94, 0x7e, 0x3b, 0x50, 0x20, 0xa7, 0x30, 0xfc, 0x3f, 0x77, 0x72, 0xb1, 0xb4, 0x67, 0x2b, 0x82,
1281         0x74, 0xcd, 0x02, 0x7f, 0x83, 0xaa, 0x4a, 0x33, 0x0d, 0xe6, 0x68, 0x36, 0x82, 0xcf, 0xe7, 0xb5,
1282         0x5d, 0xe4, 0xc1, 0x7f, 0x66, 0xed, 0xd6, 0x52, 0x23, 0x26, 0x46, 0x0b, 0x7c, 0xf0, 0xfc, 0xe6,
1283         0xd6, 0xad, 0x7c, 0xb8, 0x75, 0x2b, 0x1f, 0x6f, 0xdd, 0xca, 0x2f, 0x99, 0xeb, 0xdc, 0x64, 0xae,
1284         0xf3, 0x21, 0x73, 0x9d, 0x8f, 0x99, 0xeb, 0xfc, 0x95, 0xb9, 0xce, 0xef, 0x7f, 0xbb, 0x95, 0x1f,
1285         0xeb, 0x76, 0x5e, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x25, 0x9b, 0x14, 0x4d, 0xbd, 0x07, 0x00,
1286         0x00,
1287 }