cmd/bpa-operator/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/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/v1/generated.proto
  19
  20 /*
  21         Package v1 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/v1/generated.proto
  25
  26         It has these top-level messages:
  27                 APIGroup
  28                 APIGroupList
  29                 APIResource
  30                 APIResourceList
  31                 APIVersions
  32                 CreateOptions
  33                 DeleteOptions
  34                 Duration
  35                 ExportOptions
  36                 GetOptions
  37                 GroupKind
  38                 GroupResource
  39                 GroupVersion
  40                 GroupVersionForDiscovery
  41                 GroupVersionKind
  42                 GroupVersionResource
  43                 Initializer
  44                 Initializers
  45                 LabelSelector
  46                 LabelSelectorRequirement
  47                 List
  48                 ListMeta
  49                 ListOptions
  50                 MicroTime
  51                 ObjectMeta
  52                 OwnerReference
  53                 Patch
  54                 Preconditions
  55                 RootPaths
  56                 ServerAddressByClientCIDR
  57                 Status
  58                 StatusCause
  59                 StatusDetails
  60                 Time
  61                 Timestamp
  62                 TypeMeta
  63                 UpdateOptions
  64                 Verbs
  65                 WatchEvent
  66 */
  67 package v1
  68
  69 import proto "github.com/gogo/protobuf/proto"
  70 import fmt "fmt"
  71 import math "math"
  72
  73 import k8s_io_apimachinery_pkg_runtime "k8s.io/apimachinery/pkg/runtime"
  74
  75 import time "time"
  76 import k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
  77
  78 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  79
  80 import strings "strings"
  81 import reflect "reflect"
  82
  83 import io "io"
  84
  85 // Reference imports to suppress errors if they are not otherwise used.
  86 var _ = proto.Marshal
  87 var _ = fmt.Errorf
  88 var _ = math.Inf
  89 var _ = time.Kitchen
  90
  91 // This is a compile-time assertion to ensure that this generated file
  92 // is compatible with the proto package it is being compiled against.
  93 // A compilation error at this line likely means your copy of the
  94 // proto package needs to be updated.
  95 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  96
  97 func (m *APIGroup) Reset()                    { *m = APIGroup{} }
  98 func (*APIGroup) ProtoMessage()               {}
  99 func (*APIGroup) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
 100
 101 func (m *APIGroupList) Reset()                    { *m = APIGroupList{} }
 102 func (*APIGroupList) ProtoMessage()               {}
 103 func (*APIGroupList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
 104
 105 func (m *APIResource) Reset()                    { *m = APIResource{} }
 106 func (*APIResource) ProtoMessage()               {}
 107 func (*APIResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
 108
 109 func (m *APIResourceList) Reset()                    { *m = APIResourceList{} }
 110 func (*APIResourceList) ProtoMessage()               {}
 111 func (*APIResourceList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
 112
 113 func (m *APIVersions) Reset()                    { *m = APIVersions{} }
 114 func (*APIVersions) ProtoMessage()               {}
 115 func (*APIVersions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
 116
 117 func (m *CreateOptions) Reset()                    { *m = CreateOptions{} }
 118 func (*CreateOptions) ProtoMessage()               {}
 119 func (*CreateOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
 120
 121 func (m *DeleteOptions) Reset()                    { *m = DeleteOptions{} }
 122 func (*DeleteOptions) ProtoMessage()               {}
 123 func (*DeleteOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
 124
 125 func (m *Duration) Reset()                    { *m = Duration{} }
 126 func (*Duration) ProtoMessage()               {}
 127 func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
 128
 129 func (m *ExportOptions) Reset()                    { *m = ExportOptions{} }
 130 func (*ExportOptions) ProtoMessage()               {}
 131 func (*ExportOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
 132
 133 func (m *GetOptions) Reset()                    { *m = GetOptions{} }
 134 func (*GetOptions) ProtoMessage()               {}
 135 func (*GetOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
 136
 137 func (m *GroupKind) Reset()                    { *m = GroupKind{} }
 138 func (*GroupKind) ProtoMessage()               {}
 139 func (*GroupKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
 140
 141 func (m *GroupResource) Reset()                    { *m = GroupResource{} }
 142 func (*GroupResource) ProtoMessage()               {}
 143 func (*GroupResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
 144
 145 func (m *GroupVersion) Reset()                    { *m = GroupVersion{} }
 146 func (*GroupVersion) ProtoMessage()               {}
 147 func (*GroupVersion) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
 148
 149 func (m *GroupVersionForDiscovery) Reset()      { *m = GroupVersionForDiscovery{} }
 150 func (*GroupVersionForDiscovery) ProtoMessage() {}
 151 func (*GroupVersionForDiscovery) Descriptor() ([]byte, []int) {
 152         return fileDescriptorGenerated, []int{13}
 153 }
 154
 155 func (m *GroupVersionKind) Reset()                    { *m = GroupVersionKind{} }
 156 func (*GroupVersionKind) ProtoMessage()               {}
 157 func (*GroupVersionKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
 158
 159 func (m *GroupVersionResource) Reset()                    { *m = GroupVersionResource{} }
 160 func (*GroupVersionResource) ProtoMessage()               {}
 161 func (*GroupVersionResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
 162
 163 func (m *Initializer) Reset()                    { *m = Initializer{} }
 164 func (*Initializer) ProtoMessage()               {}
 165 func (*Initializer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
 166
 167 func (m *Initializers) Reset()                    { *m = Initializers{} }
 168 func (*Initializers) ProtoMessage()               {}
 169 func (*Initializers) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
 170
 171 func (m *LabelSelector) Reset()                    { *m = LabelSelector{} }
 172 func (*LabelSelector) ProtoMessage()               {}
 173 func (*LabelSelector) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
 174
 175 func (m *LabelSelectorRequirement) Reset()      { *m = LabelSelectorRequirement{} }
 176 func (*LabelSelectorRequirement) ProtoMessage() {}
 177 func (*LabelSelectorRequirement) Descriptor() ([]byte, []int) {
 178         return fileDescriptorGenerated, []int{19}
 179 }
 180
 181 func (m *List) Reset()                    { *m = List{} }
 182 func (*List) ProtoMessage()               {}
 183 func (*List) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
 184
 185 func (m *ListMeta) Reset()                    { *m = ListMeta{} }
 186 func (*ListMeta) ProtoMessage()               {}
 187 func (*ListMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
 188
 189 func (m *ListOptions) Reset()                    { *m = ListOptions{} }
 190 func (*ListOptions) ProtoMessage()               {}
 191 func (*ListOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
 192
 193 func (m *MicroTime) Reset()                    { *m = MicroTime{} }
 194 func (*MicroTime) ProtoMessage()               {}
 195 func (*MicroTime) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
 196
 197 func (m *ObjectMeta) Reset()                    { *m = ObjectMeta{} }
 198 func (*ObjectMeta) ProtoMessage()               {}
 199 func (*ObjectMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
 200
 201 func (m *OwnerReference) Reset()                    { *m = OwnerReference{} }
 202 func (*OwnerReference) ProtoMessage()               {}
 203 func (*OwnerReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
 204
 205 func (m *Patch) Reset()                    { *m = Patch{} }
 206 func (*Patch) ProtoMessage()               {}
 207 func (*Patch) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
 208
 209 func (m *Preconditions) Reset()                    { *m = Preconditions{} }
 210 func (*Preconditions) ProtoMessage()               {}
 211 func (*Preconditions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
 212
 213 func (m *RootPaths) Reset()                    { *m = RootPaths{} }
 214 func (*RootPaths) ProtoMessage()               {}
 215 func (*RootPaths) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
 216
 217 func (m *ServerAddressByClientCIDR) Reset()      { *m = ServerAddressByClientCIDR{} }
 218 func (*ServerAddressByClientCIDR) ProtoMessage() {}
 219 func (*ServerAddressByClientCIDR) Descriptor() ([]byte, []int) {
 220         return fileDescriptorGenerated, []int{29}
 221 }
 222
 223 func (m *Status) Reset()                    { *m = Status{} }
 224 func (*Status) ProtoMessage()               {}
 225 func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
 226
 227 func (m *StatusCause) Reset()                    { *m = StatusCause{} }
 228 func (*StatusCause) ProtoMessage()               {}
 229 func (*StatusCause) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} }
 230
 231 func (m *StatusDetails) Reset()                    { *m = StatusDetails{} }
 232 func (*StatusDetails) ProtoMessage()               {}
 233 func (*StatusDetails) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} }
 234
 235 func (m *Time) Reset()                    { *m = Time{} }
 236 func (*Time) ProtoMessage()               {}
 237 func (*Time) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
 238
 239 func (m *Timestamp) Reset()                    { *m = Timestamp{} }
 240 func (*Timestamp) ProtoMessage()               {}
 241 func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
 242
 243 func (m *TypeMeta) Reset()                    { *m = TypeMeta{} }
 244 func (*TypeMeta) ProtoMessage()               {}
 245 func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
 246
 247 func (m *UpdateOptions) Reset()                    { *m = UpdateOptions{} }
 248 func (*UpdateOptions) ProtoMessage()               {}
 249 func (*UpdateOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
 250
 251 func (m *Verbs) Reset()                    { *m = Verbs{} }
 252 func (*Verbs) ProtoMessage()               {}
 253 func (*Verbs) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
 254
 255 func (m *WatchEvent) Reset()                    { *m = WatchEvent{} }
 256 func (*WatchEvent) ProtoMessage()               {}
 257 func (*WatchEvent) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
 258
 259 func init() {
 260         proto.RegisterType((*APIGroup)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroup")
 261         proto.RegisterType((*APIGroupList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroupList")
 262         proto.RegisterType((*APIResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResource")
 263         proto.RegisterType((*APIResourceList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResourceList")
 264         proto.RegisterType((*APIVersions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIVersions")
 265         proto.RegisterType((*CreateOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.CreateOptions")
 266         proto.RegisterType((*DeleteOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.DeleteOptions")
 267         proto.RegisterType((*Duration)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Duration")
 268         proto.RegisterType((*ExportOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ExportOptions")
 269         proto.RegisterType((*GetOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GetOptions")
 270         proto.RegisterType((*GroupKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupKind")
 271         proto.RegisterType((*GroupResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupResource")
 272         proto.RegisterType((*GroupVersion)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersion")
 273         proto.RegisterType((*GroupVersionForDiscovery)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery")
 274         proto.RegisterType((*GroupVersionKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionKind")
 275         proto.RegisterType((*GroupVersionResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionResource")
 276         proto.RegisterType((*Initializer)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializer")
 277         proto.RegisterType((*Initializers)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializers")
 278         proto.RegisterType((*LabelSelector)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector")
 279         proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement")
 280         proto.RegisterType((*List)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.List")
 281         proto.RegisterType((*ListMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta")
 282         proto.RegisterType((*ListOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListOptions")
 283         proto.RegisterType((*MicroTime)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.MicroTime")
 284         proto.RegisterType((*ObjectMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta")
 285         proto.RegisterType((*OwnerReference)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.OwnerReference")
 286         proto.RegisterType((*Patch)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Patch")
 287         proto.RegisterType((*Preconditions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Preconditions")
 288         proto.RegisterType((*RootPaths)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.RootPaths")
 289         proto.RegisterType((*ServerAddressByClientCIDR)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR")
 290         proto.RegisterType((*Status)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Status")
 291         proto.RegisterType((*StatusCause)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusCause")
 292         proto.RegisterType((*StatusDetails)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusDetails")
 293         proto.RegisterType((*Time)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Time")
 294         proto.RegisterType((*Timestamp)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Timestamp")
 295         proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.TypeMeta")
 296         proto.RegisterType((*UpdateOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.UpdateOptions")
 297         proto.RegisterType((*Verbs)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Verbs")
 298         proto.RegisterType((*WatchEvent)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.WatchEvent")
 299 }
 300 func (m *APIGroup) Marshal() (dAtA []byte, err error) {
 301         size := m.Size()
 302         dAtA = make([]byte, size)
 303         n, err := m.MarshalTo(dAtA)
 304         if err != nil {
 305                 return nil, err
 306         }
 307         return dAtA[:n], nil
 308 }
 309
 310 func (m *APIGroup) MarshalTo(dAtA []byte) (int, error) {
 311         var i int
 312         _ = i
 313         var l int
 314         _ = l
 315         dAtA[i] = 0xa
 316         i++
 317         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 318         i += copy(dAtA[i:], m.Name)
 319         if len(m.Versions) > 0 {
 320                 for _, msg := range m.Versions {
 321                         dAtA[i] = 0x12
 322                         i++
 323                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 324                         n, err := msg.MarshalTo(dAtA[i:])
 325                         if err != nil {
 326                                 return 0, err
 327                         }
 328                         i += n
 329                 }
 330         }
 331         dAtA[i] = 0x1a
 332         i++
 333         i = encodeVarintGenerated(dAtA, i, uint64(m.PreferredVersion.Size()))
 334         n1, err := m.PreferredVersion.MarshalTo(dAtA[i:])
 335         if err != nil {
 336                 return 0, err
 337         }
 338         i += n1
 339         if len(m.ServerAddressByClientCIDRs) > 0 {
 340                 for _, msg := range m.ServerAddressByClientCIDRs {
 341                         dAtA[i] = 0x22
 342                         i++
 343                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 344                         n, err := msg.MarshalTo(dAtA[i:])
 345                         if err != nil {
 346                                 return 0, err
 347                         }
 348                         i += n
 349                 }
 350         }
 351         return i, nil
 352 }
 353
 354 func (m *APIGroupList) Marshal() (dAtA []byte, err error) {
 355         size := m.Size()
 356         dAtA = make([]byte, size)
 357         n, err := m.MarshalTo(dAtA)
 358         if err != nil {
 359                 return nil, err
 360         }
 361         return dAtA[:n], nil
 362 }
 363
 364 func (m *APIGroupList) MarshalTo(dAtA []byte) (int, error) {
 365         var i int
 366         _ = i
 367         var l int
 368         _ = l
 369         if len(m.Groups) > 0 {
 370                 for _, msg := range m.Groups {
 371                         dAtA[i] = 0xa
 372                         i++
 373                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 374                         n, err := msg.MarshalTo(dAtA[i:])
 375                         if err != nil {
 376                                 return 0, err
 377                         }
 378                         i += n
 379                 }
 380         }
 381         return i, nil
 382 }
 383
 384 func (m *APIResource) Marshal() (dAtA []byte, err error) {
 385         size := m.Size()
 386         dAtA = make([]byte, size)
 387         n, err := m.MarshalTo(dAtA)
 388         if err != nil {
 389                 return nil, err
 390         }
 391         return dAtA[:n], nil
 392 }
 393
 394 func (m *APIResource) MarshalTo(dAtA []byte) (int, error) {
 395         var i int
 396         _ = i
 397         var l int
 398         _ = l
 399         dAtA[i] = 0xa
 400         i++
 401         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 402         i += copy(dAtA[i:], m.Name)
 403         dAtA[i] = 0x10
 404         i++
 405         if m.Namespaced {
 406                 dAtA[i] = 1
 407         } else {
 408                 dAtA[i] = 0
 409         }
 410         i++
 411         dAtA[i] = 0x1a
 412         i++
 413         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 414         i += copy(dAtA[i:], m.Kind)
 415         if m.Verbs != nil {
 416                 dAtA[i] = 0x22
 417                 i++
 418                 i = encodeVarintGenerated(dAtA, i, uint64(m.Verbs.Size()))
 419                 n2, err := m.Verbs.MarshalTo(dAtA[i:])
 420                 if err != nil {
 421                         return 0, err
 422                 }
 423                 i += n2
 424         }
 425         if len(m.ShortNames) > 0 {
 426                 for _, s := range m.ShortNames {
 427                         dAtA[i] = 0x2a
 428                         i++
 429                         l = len(s)
 430                         for l >= 1<<7 {
 431                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 432                                 l >>= 7
 433                                 i++
 434                         }
 435                         dAtA[i] = uint8(l)
 436                         i++
 437                         i += copy(dAtA[i:], s)
 438                 }
 439         }
 440         dAtA[i] = 0x32
 441         i++
 442         i = encodeVarintGenerated(dAtA, i, uint64(len(m.SingularName)))
 443         i += copy(dAtA[i:], m.SingularName)
 444         if len(m.Categories) > 0 {
 445                 for _, s := range m.Categories {
 446                         dAtA[i] = 0x3a
 447                         i++
 448                         l = len(s)
 449                         for l >= 1<<7 {
 450                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 451                                 l >>= 7
 452                                 i++
 453                         }
 454                         dAtA[i] = uint8(l)
 455                         i++
 456                         i += copy(dAtA[i:], s)
 457                 }
 458         }
 459         dAtA[i] = 0x42
 460         i++
 461         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 462         i += copy(dAtA[i:], m.Group)
 463         dAtA[i] = 0x4a
 464         i++
 465         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 466         i += copy(dAtA[i:], m.Version)
 467         return i, nil
 468 }
 469
 470 func (m *APIResourceList) Marshal() (dAtA []byte, err error) {
 471         size := m.Size()
 472         dAtA = make([]byte, size)
 473         n, err := m.MarshalTo(dAtA)
 474         if err != nil {
 475                 return nil, err
 476         }
 477         return dAtA[:n], nil
 478 }
 479
 480 func (m *APIResourceList) MarshalTo(dAtA []byte) (int, error) {
 481         var i int
 482         _ = i
 483         var l int
 484         _ = l
 485         dAtA[i] = 0xa
 486         i++
 487         i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion)))
 488         i += copy(dAtA[i:], m.GroupVersion)
 489         if len(m.APIResources) > 0 {
 490                 for _, msg := range m.APIResources {
 491                         dAtA[i] = 0x12
 492                         i++
 493                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 494                         n, err := msg.MarshalTo(dAtA[i:])
 495                         if err != nil {
 496                                 return 0, err
 497                         }
 498                         i += n
 499                 }
 500         }
 501         return i, nil
 502 }
 503
 504 func (m *APIVersions) Marshal() (dAtA []byte, err error) {
 505         size := m.Size()
 506         dAtA = make([]byte, size)
 507         n, err := m.MarshalTo(dAtA)
 508         if err != nil {
 509                 return nil, err
 510         }
 511         return dAtA[:n], nil
 512 }
 513
 514 func (m *APIVersions) MarshalTo(dAtA []byte) (int, error) {
 515         var i int
 516         _ = i
 517         var l int
 518         _ = l
 519         if len(m.Versions) > 0 {
 520                 for _, s := range m.Versions {
 521                         dAtA[i] = 0xa
 522                         i++
 523                         l = len(s)
 524                         for l >= 1<<7 {
 525                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 526                                 l >>= 7
 527                                 i++
 528                         }
 529                         dAtA[i] = uint8(l)
 530                         i++
 531                         i += copy(dAtA[i:], s)
 532                 }
 533         }
 534         if len(m.ServerAddressByClientCIDRs) > 0 {
 535                 for _, msg := range m.ServerAddressByClientCIDRs {
 536                         dAtA[i] = 0x12
 537                         i++
 538                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 539                         n, err := msg.MarshalTo(dAtA[i:])
 540                         if err != nil {
 541                                 return 0, err
 542                         }
 543                         i += n
 544                 }
 545         }
 546         return i, nil
 547 }
 548
 549 func (m *CreateOptions) Marshal() (dAtA []byte, err error) {
 550         size := m.Size()
 551         dAtA = make([]byte, size)
 552         n, err := m.MarshalTo(dAtA)
 553         if err != nil {
 554                 return nil, err
 555         }
 556         return dAtA[:n], nil
 557 }
 558
 559 func (m *CreateOptions) MarshalTo(dAtA []byte) (int, error) {
 560         var i int
 561         _ = i
 562         var l int
 563         _ = l
 564         if len(m.DryRun) > 0 {
 565                 for _, s := range m.DryRun {
 566                         dAtA[i] = 0xa
 567                         i++
 568                         l = len(s)
 569                         for l >= 1<<7 {
 570                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 571                                 l >>= 7
 572                                 i++
 573                         }
 574                         dAtA[i] = uint8(l)
 575                         i++
 576                         i += copy(dAtA[i:], s)
 577                 }
 578         }
 579         dAtA[i] = 0x10
 580         i++
 581         if m.IncludeUninitialized {
 582                 dAtA[i] = 1
 583         } else {
 584                 dAtA[i] = 0
 585         }
 586         i++
 587         return i, nil
 588 }
 589
 590 func (m *DeleteOptions) Marshal() (dAtA []byte, err error) {
 591         size := m.Size()
 592         dAtA = make([]byte, size)
 593         n, err := m.MarshalTo(dAtA)
 594         if err != nil {
 595                 return nil, err
 596         }
 597         return dAtA[:n], nil
 598 }
 599
 600 func (m *DeleteOptions) MarshalTo(dAtA []byte) (int, error) {
 601         var i int
 602         _ = i
 603         var l int
 604         _ = l
 605         if m.GracePeriodSeconds != nil {
 606                 dAtA[i] = 0x8
 607                 i++
 608                 i = encodeVarintGenerated(dAtA, i, uint64(*m.GracePeriodSeconds))
 609         }
 610         if m.Preconditions != nil {
 611                 dAtA[i] = 0x12
 612                 i++
 613                 i = encodeVarintGenerated(dAtA, i, uint64(m.Preconditions.Size()))
 614                 n3, err := m.Preconditions.MarshalTo(dAtA[i:])
 615                 if err != nil {
 616                         return 0, err
 617                 }
 618                 i += n3
 619         }
 620         if m.OrphanDependents != nil {
 621                 dAtA[i] = 0x18
 622                 i++
 623                 if *m.OrphanDependents {
 624                         dAtA[i] = 1
 625                 } else {
 626                         dAtA[i] = 0
 627                 }
 628                 i++
 629         }
 630         if m.PropagationPolicy != nil {
 631                 dAtA[i] = 0x22
 632                 i++
 633                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PropagationPolicy)))
 634                 i += copy(dAtA[i:], *m.PropagationPolicy)
 635         }
 636         if len(m.DryRun) > 0 {
 637                 for _, s := range m.DryRun {
 638                         dAtA[i] = 0x2a
 639                         i++
 640                         l = len(s)
 641                         for l >= 1<<7 {
 642                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 643                                 l >>= 7
 644                                 i++
 645                         }
 646                         dAtA[i] = uint8(l)
 647                         i++
 648                         i += copy(dAtA[i:], s)
 649                 }
 650         }
 651         return i, nil
 652 }
 653
 654 func (m *Duration) Marshal() (dAtA []byte, err error) {
 655         size := m.Size()
 656         dAtA = make([]byte, size)
 657         n, err := m.MarshalTo(dAtA)
 658         if err != nil {
 659                 return nil, err
 660         }
 661         return dAtA[:n], nil
 662 }
 663
 664 func (m *Duration) MarshalTo(dAtA []byte) (int, error) {
 665         var i int
 666         _ = i
 667         var l int
 668         _ = l
 669         dAtA[i] = 0x8
 670         i++
 671         i = encodeVarintGenerated(dAtA, i, uint64(m.Duration))
 672         return i, nil
 673 }
 674
 675 func (m *ExportOptions) Marshal() (dAtA []byte, err error) {
 676         size := m.Size()
 677         dAtA = make([]byte, size)
 678         n, err := m.MarshalTo(dAtA)
 679         if err != nil {
 680                 return nil, err
 681         }
 682         return dAtA[:n], nil
 683 }
 684
 685 func (m *ExportOptions) MarshalTo(dAtA []byte) (int, error) {
 686         var i int
 687         _ = i
 688         var l int
 689         _ = l
 690         dAtA[i] = 0x8
 691         i++
 692         if m.Export {
 693                 dAtA[i] = 1
 694         } else {
 695                 dAtA[i] = 0
 696         }
 697         i++
 698         dAtA[i] = 0x10
 699         i++
 700         if m.Exact {
 701                 dAtA[i] = 1
 702         } else {
 703                 dAtA[i] = 0
 704         }
 705         i++
 706         return i, nil
 707 }
 708
 709 func (m *GetOptions) Marshal() (dAtA []byte, err error) {
 710         size := m.Size()
 711         dAtA = make([]byte, size)
 712         n, err := m.MarshalTo(dAtA)
 713         if err != nil {
 714                 return nil, err
 715         }
 716         return dAtA[:n], nil
 717 }
 718
 719 func (m *GetOptions) MarshalTo(dAtA []byte) (int, error) {
 720         var i int
 721         _ = i
 722         var l int
 723         _ = l
 724         dAtA[i] = 0xa
 725         i++
 726         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
 727         i += copy(dAtA[i:], m.ResourceVersion)
 728         dAtA[i] = 0x10
 729         i++
 730         if m.IncludeUninitialized {
 731                 dAtA[i] = 1
 732         } else {
 733                 dAtA[i] = 0
 734         }
 735         i++
 736         return i, nil
 737 }
 738
 739 func (m *GroupKind) Marshal() (dAtA []byte, err error) {
 740         size := m.Size()
 741         dAtA = make([]byte, size)
 742         n, err := m.MarshalTo(dAtA)
 743         if err != nil {
 744                 return nil, err
 745         }
 746         return dAtA[:n], nil
 747 }
 748
 749 func (m *GroupKind) MarshalTo(dAtA []byte) (int, error) {
 750         var i int
 751         _ = i
 752         var l int
 753         _ = l
 754         dAtA[i] = 0xa
 755         i++
 756         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 757         i += copy(dAtA[i:], m.Group)
 758         dAtA[i] = 0x12
 759         i++
 760         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 761         i += copy(dAtA[i:], m.Kind)
 762         return i, nil
 763 }
 764
 765 func (m *GroupResource) Marshal() (dAtA []byte, err error) {
 766         size := m.Size()
 767         dAtA = make([]byte, size)
 768         n, err := m.MarshalTo(dAtA)
 769         if err != nil {
 770                 return nil, err
 771         }
 772         return dAtA[:n], nil
 773 }
 774
 775 func (m *GroupResource) MarshalTo(dAtA []byte) (int, error) {
 776         var i int
 777         _ = i
 778         var l int
 779         _ = l
 780         dAtA[i] = 0xa
 781         i++
 782         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 783         i += copy(dAtA[i:], m.Group)
 784         dAtA[i] = 0x12
 785         i++
 786         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
 787         i += copy(dAtA[i:], m.Resource)
 788         return i, nil
 789 }
 790
 791 func (m *GroupVersion) Marshal() (dAtA []byte, err error) {
 792         size := m.Size()
 793         dAtA = make([]byte, size)
 794         n, err := m.MarshalTo(dAtA)
 795         if err != nil {
 796                 return nil, err
 797         }
 798         return dAtA[:n], nil
 799 }
 800
 801 func (m *GroupVersion) MarshalTo(dAtA []byte) (int, error) {
 802         var i int
 803         _ = i
 804         var l int
 805         _ = l
 806         dAtA[i] = 0xa
 807         i++
 808         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 809         i += copy(dAtA[i:], m.Group)
 810         dAtA[i] = 0x12
 811         i++
 812         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 813         i += copy(dAtA[i:], m.Version)
 814         return i, nil
 815 }
 816
 817 func (m *GroupVersionForDiscovery) Marshal() (dAtA []byte, err error) {
 818         size := m.Size()
 819         dAtA = make([]byte, size)
 820         n, err := m.MarshalTo(dAtA)
 821         if err != nil {
 822                 return nil, err
 823         }
 824         return dAtA[:n], nil
 825 }
 826
 827 func (m *GroupVersionForDiscovery) MarshalTo(dAtA []byte) (int, error) {
 828         var i int
 829         _ = i
 830         var l int
 831         _ = l
 832         dAtA[i] = 0xa
 833         i++
 834         i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion)))
 835         i += copy(dAtA[i:], m.GroupVersion)
 836         dAtA[i] = 0x12
 837         i++
 838         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 839         i += copy(dAtA[i:], m.Version)
 840         return i, nil
 841 }
 842
 843 func (m *GroupVersionKind) Marshal() (dAtA []byte, err error) {
 844         size := m.Size()
 845         dAtA = make([]byte, size)
 846         n, err := m.MarshalTo(dAtA)
 847         if err != nil {
 848                 return nil, err
 849         }
 850         return dAtA[:n], nil
 851 }
 852
 853 func (m *GroupVersionKind) MarshalTo(dAtA []byte) (int, error) {
 854         var i int
 855         _ = i
 856         var l int
 857         _ = l
 858         dAtA[i] = 0xa
 859         i++
 860         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 861         i += copy(dAtA[i:], m.Group)
 862         dAtA[i] = 0x12
 863         i++
 864         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 865         i += copy(dAtA[i:], m.Version)
 866         dAtA[i] = 0x1a
 867         i++
 868         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 869         i += copy(dAtA[i:], m.Kind)
 870         return i, nil
 871 }
 872
 873 func (m *GroupVersionResource) Marshal() (dAtA []byte, err error) {
 874         size := m.Size()
 875         dAtA = make([]byte, size)
 876         n, err := m.MarshalTo(dAtA)
 877         if err != nil {
 878                 return nil, err
 879         }
 880         return dAtA[:n], nil
 881 }
 882
 883 func (m *GroupVersionResource) MarshalTo(dAtA []byte) (int, error) {
 884         var i int
 885         _ = i
 886         var l int
 887         _ = l
 888         dAtA[i] = 0xa
 889         i++
 890         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
 891         i += copy(dAtA[i:], m.Group)
 892         dAtA[i] = 0x12
 893         i++
 894         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
 895         i += copy(dAtA[i:], m.Version)
 896         dAtA[i] = 0x1a
 897         i++
 898         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
 899         i += copy(dAtA[i:], m.Resource)
 900         return i, nil
 901 }
 902
 903 func (m *Initializer) Marshal() (dAtA []byte, err error) {
 904         size := m.Size()
 905         dAtA = make([]byte, size)
 906         n, err := m.MarshalTo(dAtA)
 907         if err != nil {
 908                 return nil, err
 909         }
 910         return dAtA[:n], nil
 911 }
 912
 913 func (m *Initializer) MarshalTo(dAtA []byte) (int, error) {
 914         var i int
 915         _ = i
 916         var l int
 917         _ = l
 918         dAtA[i] = 0xa
 919         i++
 920         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 921         i += copy(dAtA[i:], m.Name)
 922         return i, nil
 923 }
 924
 925 func (m *Initializers) Marshal() (dAtA []byte, err error) {
 926         size := m.Size()
 927         dAtA = make([]byte, size)
 928         n, err := m.MarshalTo(dAtA)
 929         if err != nil {
 930                 return nil, err
 931         }
 932         return dAtA[:n], nil
 933 }
 934
 935 func (m *Initializers) MarshalTo(dAtA []byte) (int, error) {
 936         var i int
 937         _ = i
 938         var l int
 939         _ = l
 940         if len(m.Pending) > 0 {
 941                 for _, msg := range m.Pending {
 942                         dAtA[i] = 0xa
 943                         i++
 944                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 945                         n, err := msg.MarshalTo(dAtA[i:])
 946                         if err != nil {
 947                                 return 0, err
 948                         }
 949                         i += n
 950                 }
 951         }
 952         if m.Result != nil {
 953                 dAtA[i] = 0x12
 954                 i++
 955                 i = encodeVarintGenerated(dAtA, i, uint64(m.Result.Size()))
 956                 n4, err := m.Result.MarshalTo(dAtA[i:])
 957                 if err != nil {
 958                         return 0, err
 959                 }
 960                 i += n4
 961         }
 962         return i, nil
 963 }
 964
 965 func (m *LabelSelector) Marshal() (dAtA []byte, err error) {
 966         size := m.Size()
 967         dAtA = make([]byte, size)
 968         n, err := m.MarshalTo(dAtA)
 969         if err != nil {
 970                 return nil, err
 971         }
 972         return dAtA[:n], nil
 973 }
 974
 975 func (m *LabelSelector) MarshalTo(dAtA []byte) (int, error) {
 976         var i int
 977         _ = i
 978         var l int
 979         _ = l
 980         if len(m.MatchLabels) > 0 {
 981                 keysForMatchLabels := make([]string, 0, len(m.MatchLabels))
 982                 for k := range m.MatchLabels {
 983                         keysForMatchLabels = append(keysForMatchLabels, string(k))
 984                 }
 985                 github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
 986                 for _, k := range keysForMatchLabels {
 987                         dAtA[i] = 0xa
 988                         i++
 989                         v := m.MatchLabels[string(k)]
 990                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 991                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 992                         dAtA[i] = 0xa
 993                         i++
 994                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 995                         i += copy(dAtA[i:], k)
 996                         dAtA[i] = 0x12
 997                         i++
 998                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
 999                         i += copy(dAtA[i:], v)
1000                 }
1001         }
1002         if len(m.MatchExpressions) > 0 {
1003                 for _, msg := range m.MatchExpressions {
1004                         dAtA[i] = 0x12
1005                         i++
1006                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1007                         n, err := msg.MarshalTo(dAtA[i:])
1008                         if err != nil {
1009                                 return 0, err
1010                         }
1011                         i += n
1012                 }
1013         }
1014         return i, nil
1015 }
1016
1017 func (m *LabelSelectorRequirement) Marshal() (dAtA []byte, err error) {
1018         size := m.Size()
1019         dAtA = make([]byte, size)
1020         n, err := m.MarshalTo(dAtA)
1021         if err != nil {
1022                 return nil, err
1023         }
1024         return dAtA[:n], nil
1025 }
1026
1027 func (m *LabelSelectorRequirement) MarshalTo(dAtA []byte) (int, error) {
1028         var i int
1029         _ = i
1030         var l int
1031         _ = l
1032         dAtA[i] = 0xa
1033         i++
1034         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
1035         i += copy(dAtA[i:], m.Key)
1036         dAtA[i] = 0x12
1037         i++
1038         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator)))
1039         i += copy(dAtA[i:], m.Operator)
1040         if len(m.Values) > 0 {
1041                 for _, s := range m.Values {
1042                         dAtA[i] = 0x1a
1043                         i++
1044                         l = len(s)
1045                         for l >= 1<<7 {
1046                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1047                                 l >>= 7
1048                                 i++
1049                         }
1050                         dAtA[i] = uint8(l)
1051                         i++
1052                         i += copy(dAtA[i:], s)
1053                 }
1054         }
1055         return i, nil
1056 }
1057
1058 func (m *List) Marshal() (dAtA []byte, err error) {
1059         size := m.Size()
1060         dAtA = make([]byte, size)
1061         n, err := m.MarshalTo(dAtA)
1062         if err != nil {
1063                 return nil, err
1064         }
1065         return dAtA[:n], nil
1066 }
1067
1068 func (m *List) MarshalTo(dAtA []byte) (int, error) {
1069         var i int
1070         _ = i
1071         var l int
1072         _ = l
1073         dAtA[i] = 0xa
1074         i++
1075         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1076         n5, err := m.ListMeta.MarshalTo(dAtA[i:])
1077         if err != nil {
1078                 return 0, err
1079         }
1080         i += n5
1081         if len(m.Items) > 0 {
1082                 for _, msg := range m.Items {
1083                         dAtA[i] = 0x12
1084                         i++
1085                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1086                         n, err := msg.MarshalTo(dAtA[i:])
1087                         if err != nil {
1088                                 return 0, err
1089                         }
1090                         i += n
1091                 }
1092         }
1093         return i, nil
1094 }
1095
1096 func (m *ListMeta) Marshal() (dAtA []byte, err error) {
1097         size := m.Size()
1098         dAtA = make([]byte, size)
1099         n, err := m.MarshalTo(dAtA)
1100         if err != nil {
1101                 return nil, err
1102         }
1103         return dAtA[:n], nil
1104 }
1105
1106 func (m *ListMeta) MarshalTo(dAtA []byte) (int, error) {
1107         var i int
1108         _ = i
1109         var l int
1110         _ = l
1111         dAtA[i] = 0xa
1112         i++
1113         i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink)))
1114         i += copy(dAtA[i:], m.SelfLink)
1115         dAtA[i] = 0x12
1116         i++
1117         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
1118         i += copy(dAtA[i:], m.ResourceVersion)
1119         dAtA[i] = 0x1a
1120         i++
1121         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue)))
1122         i += copy(dAtA[i:], m.Continue)
1123         return i, nil
1124 }
1125
1126 func (m *ListOptions) Marshal() (dAtA []byte, err error) {
1127         size := m.Size()
1128         dAtA = make([]byte, size)
1129         n, err := m.MarshalTo(dAtA)
1130         if err != nil {
1131                 return nil, err
1132         }
1133         return dAtA[:n], nil
1134 }
1135
1136 func (m *ListOptions) MarshalTo(dAtA []byte) (int, error) {
1137         var i int
1138         _ = i
1139         var l int
1140         _ = l
1141         dAtA[i] = 0xa
1142         i++
1143         i = encodeVarintGenerated(dAtA, i, uint64(len(m.LabelSelector)))
1144         i += copy(dAtA[i:], m.LabelSelector)
1145         dAtA[i] = 0x12
1146         i++
1147         i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldSelector)))
1148         i += copy(dAtA[i:], m.FieldSelector)
1149         dAtA[i] = 0x18
1150         i++
1151         if m.Watch {
1152                 dAtA[i] = 1
1153         } else {
1154                 dAtA[i] = 0
1155         }
1156         i++
1157         dAtA[i] = 0x22
1158         i++
1159         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
1160         i += copy(dAtA[i:], m.ResourceVersion)
1161         if m.TimeoutSeconds != nil {
1162                 dAtA[i] = 0x28
1163                 i++
1164                 i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
1165         }
1166         dAtA[i] = 0x30
1167         i++
1168         if m.IncludeUninitialized {
1169                 dAtA[i] = 1
1170         } else {
1171                 dAtA[i] = 0
1172         }
1173         i++
1174         dAtA[i] = 0x38
1175         i++
1176         i = encodeVarintGenerated(dAtA, i, uint64(m.Limit))
1177         dAtA[i] = 0x42
1178         i++
1179         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue)))
1180         i += copy(dAtA[i:], m.Continue)
1181         return i, nil
1182 }
1183
1184 func (m *ObjectMeta) Marshal() (dAtA []byte, err error) {
1185         size := m.Size()
1186         dAtA = make([]byte, size)
1187         n, err := m.MarshalTo(dAtA)
1188         if err != nil {
1189                 return nil, err
1190         }
1191         return dAtA[:n], nil
1192 }
1193
1194 func (m *ObjectMeta) MarshalTo(dAtA []byte) (int, error) {
1195         var i int
1196         _ = i
1197         var l int
1198         _ = l
1199         dAtA[i] = 0xa
1200         i++
1201         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1202         i += copy(dAtA[i:], m.Name)
1203         dAtA[i] = 0x12
1204         i++
1205         i = encodeVarintGenerated(dAtA, i, uint64(len(m.GenerateName)))
1206         i += copy(dAtA[i:], m.GenerateName)
1207         dAtA[i] = 0x1a
1208         i++
1209         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
1210         i += copy(dAtA[i:], m.Namespace)
1211         dAtA[i] = 0x22
1212         i++
1213         i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink)))
1214         i += copy(dAtA[i:], m.SelfLink)
1215         dAtA[i] = 0x2a
1216         i++
1217         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1218         i += copy(dAtA[i:], m.UID)
1219         dAtA[i] = 0x32
1220         i++
1221         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
1222         i += copy(dAtA[i:], m.ResourceVersion)
1223         dAtA[i] = 0x38
1224         i++
1225         i = encodeVarintGenerated(dAtA, i, uint64(m.Generation))
1226         dAtA[i] = 0x42
1227         i++
1228         i = encodeVarintGenerated(dAtA, i, uint64(m.CreationTimestamp.Size()))
1229         n6, err := m.CreationTimestamp.MarshalTo(dAtA[i:])
1230         if err != nil {
1231                 return 0, err
1232         }
1233         i += n6
1234         if m.DeletionTimestamp != nil {
1235                 dAtA[i] = 0x4a
1236                 i++
1237                 i = encodeVarintGenerated(dAtA, i, uint64(m.DeletionTimestamp.Size()))
1238                 n7, err := m.DeletionTimestamp.MarshalTo(dAtA[i:])
1239                 if err != nil {
1240                         return 0, err
1241                 }
1242                 i += n7
1243         }
1244         if m.DeletionGracePeriodSeconds != nil {
1245                 dAtA[i] = 0x50
1246                 i++
1247                 i = encodeVarintGenerated(dAtA, i, uint64(*m.DeletionGracePeriodSeconds))
1248         }
1249         if len(m.Labels) > 0 {
1250                 keysForLabels := make([]string, 0, len(m.Labels))
1251                 for k := range m.Labels {
1252                         keysForLabels = append(keysForLabels, string(k))
1253                 }
1254                 github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
1255                 for _, k := range keysForLabels {
1256                         dAtA[i] = 0x5a
1257                         i++
1258                         v := m.Labels[string(k)]
1259                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1260                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1261                         dAtA[i] = 0xa
1262                         i++
1263                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1264                         i += copy(dAtA[i:], k)
1265                         dAtA[i] = 0x12
1266                         i++
1267                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1268                         i += copy(dAtA[i:], v)
1269                 }
1270         }
1271         if len(m.Annotations) > 0 {
1272                 keysForAnnotations := make([]string, 0, len(m.Annotations))
1273                 for k := range m.Annotations {
1274                         keysForAnnotations = append(keysForAnnotations, string(k))
1275                 }
1276                 github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
1277                 for _, k := range keysForAnnotations {
1278                         dAtA[i] = 0x62
1279                         i++
1280                         v := m.Annotations[string(k)]
1281                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1282                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1283                         dAtA[i] = 0xa
1284                         i++
1285                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1286                         i += copy(dAtA[i:], k)
1287                         dAtA[i] = 0x12
1288                         i++
1289                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1290                         i += copy(dAtA[i:], v)
1291                 }
1292         }
1293         if len(m.OwnerReferences) > 0 {
1294                 for _, msg := range m.OwnerReferences {
1295                         dAtA[i] = 0x6a
1296                         i++
1297                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1298                         n, err := msg.MarshalTo(dAtA[i:])
1299                         if err != nil {
1300                                 return 0, err
1301                         }
1302                         i += n
1303                 }
1304         }
1305         if len(m.Finalizers) > 0 {
1306                 for _, s := range m.Finalizers {
1307                         dAtA[i] = 0x72
1308                         i++
1309                         l = len(s)
1310                         for l >= 1<<7 {
1311                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1312                                 l >>= 7
1313                                 i++
1314                         }
1315                         dAtA[i] = uint8(l)
1316                         i++
1317                         i += copy(dAtA[i:], s)
1318                 }
1319         }
1320         dAtA[i] = 0x7a
1321         i++
1322         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClusterName)))
1323         i += copy(dAtA[i:], m.ClusterName)
1324         if m.Initializers != nil {
1325                 dAtA[i] = 0x82
1326                 i++
1327                 dAtA[i] = 0x1
1328                 i++
1329                 i = encodeVarintGenerated(dAtA, i, uint64(m.Initializers.Size()))
1330                 n8, err := m.Initializers.MarshalTo(dAtA[i:])
1331                 if err != nil {
1332                         return 0, err
1333                 }
1334                 i += n8
1335         }
1336         return i, nil
1337 }
1338
1339 func (m *OwnerReference) Marshal() (dAtA []byte, err error) {
1340         size := m.Size()
1341         dAtA = make([]byte, size)
1342         n, err := m.MarshalTo(dAtA)
1343         if err != nil {
1344                 return nil, err
1345         }
1346         return dAtA[:n], nil
1347 }
1348
1349 func (m *OwnerReference) MarshalTo(dAtA []byte) (int, error) {
1350         var i int
1351         _ = i
1352         var l int
1353         _ = l
1354         dAtA[i] = 0xa
1355         i++
1356         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1357         i += copy(dAtA[i:], m.Kind)
1358         dAtA[i] = 0x1a
1359         i++
1360         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1361         i += copy(dAtA[i:], m.Name)
1362         dAtA[i] = 0x22
1363         i++
1364         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1365         i += copy(dAtA[i:], m.UID)
1366         dAtA[i] = 0x2a
1367         i++
1368         i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
1369         i += copy(dAtA[i:], m.APIVersion)
1370         if m.Controller != nil {
1371                 dAtA[i] = 0x30
1372                 i++
1373                 if *m.Controller {
1374                         dAtA[i] = 1
1375                 } else {
1376                         dAtA[i] = 0
1377                 }
1378                 i++
1379         }
1380         if m.BlockOwnerDeletion != nil {
1381                 dAtA[i] = 0x38
1382                 i++
1383                 if *m.BlockOwnerDeletion {
1384                         dAtA[i] = 1
1385                 } else {
1386                         dAtA[i] = 0
1387                 }
1388                 i++
1389         }
1390         return i, nil
1391 }
1392
1393 func (m *Patch) Marshal() (dAtA []byte, err error) {
1394         size := m.Size()
1395         dAtA = make([]byte, size)
1396         n, err := m.MarshalTo(dAtA)
1397         if err != nil {
1398                 return nil, err
1399         }
1400         return dAtA[:n], nil
1401 }
1402
1403 func (m *Patch) MarshalTo(dAtA []byte) (int, error) {
1404         var i int
1405         _ = i
1406         var l int
1407         _ = l
1408         return i, nil
1409 }
1410
1411 func (m *Preconditions) Marshal() (dAtA []byte, err error) {
1412         size := m.Size()
1413         dAtA = make([]byte, size)
1414         n, err := m.MarshalTo(dAtA)
1415         if err != nil {
1416                 return nil, err
1417         }
1418         return dAtA[:n], nil
1419 }
1420
1421 func (m *Preconditions) MarshalTo(dAtA []byte) (int, error) {
1422         var i int
1423         _ = i
1424         var l int
1425         _ = l
1426         if m.UID != nil {
1427                 dAtA[i] = 0xa
1428                 i++
1429                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UID)))
1430                 i += copy(dAtA[i:], *m.UID)
1431         }
1432         return i, nil
1433 }
1434
1435 func (m *RootPaths) Marshal() (dAtA []byte, err error) {
1436         size := m.Size()
1437         dAtA = make([]byte, size)
1438         n, err := m.MarshalTo(dAtA)
1439         if err != nil {
1440                 return nil, err
1441         }
1442         return dAtA[:n], nil
1443 }
1444
1445 func (m *RootPaths) MarshalTo(dAtA []byte) (int, error) {
1446         var i int
1447         _ = i
1448         var l int
1449         _ = l
1450         if len(m.Paths) > 0 {
1451                 for _, s := range m.Paths {
1452                         dAtA[i] = 0xa
1453                         i++
1454                         l = len(s)
1455                         for l >= 1<<7 {
1456                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1457                                 l >>= 7
1458                                 i++
1459                         }
1460                         dAtA[i] = uint8(l)
1461                         i++
1462                         i += copy(dAtA[i:], s)
1463                 }
1464         }
1465         return i, nil
1466 }
1467
1468 func (m *ServerAddressByClientCIDR) Marshal() (dAtA []byte, err error) {
1469         size := m.Size()
1470         dAtA = make([]byte, size)
1471         n, err := m.MarshalTo(dAtA)
1472         if err != nil {
1473                 return nil, err
1474         }
1475         return dAtA[:n], nil
1476 }
1477
1478 func (m *ServerAddressByClientCIDR) MarshalTo(dAtA []byte) (int, error) {
1479         var i int
1480         _ = i
1481         var l int
1482         _ = l
1483         dAtA[i] = 0xa
1484         i++
1485         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientCIDR)))
1486         i += copy(dAtA[i:], m.ClientCIDR)
1487         dAtA[i] = 0x12
1488         i++
1489         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServerAddress)))
1490         i += copy(dAtA[i:], m.ServerAddress)
1491         return i, nil
1492 }
1493
1494 func (m *Status) Marshal() (dAtA []byte, err error) {
1495         size := m.Size()
1496         dAtA = make([]byte, size)
1497         n, err := m.MarshalTo(dAtA)
1498         if err != nil {
1499                 return nil, err
1500         }
1501         return dAtA[:n], nil
1502 }
1503
1504 func (m *Status) MarshalTo(dAtA []byte) (int, error) {
1505         var i int
1506         _ = i
1507         var l int
1508         _ = l
1509         dAtA[i] = 0xa
1510         i++
1511         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1512         n9, err := m.ListMeta.MarshalTo(dAtA[i:])
1513         if err != nil {
1514                 return 0, err
1515         }
1516         i += n9
1517         dAtA[i] = 0x12
1518         i++
1519         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1520         i += copy(dAtA[i:], m.Status)
1521         dAtA[i] = 0x1a
1522         i++
1523         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1524         i += copy(dAtA[i:], m.Message)
1525         dAtA[i] = 0x22
1526         i++
1527         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1528         i += copy(dAtA[i:], m.Reason)
1529         if m.Details != nil {
1530                 dAtA[i] = 0x2a
1531                 i++
1532                 i = encodeVarintGenerated(dAtA, i, uint64(m.Details.Size()))
1533                 n10, err := m.Details.MarshalTo(dAtA[i:])
1534                 if err != nil {
1535                         return 0, err
1536                 }
1537                 i += n10
1538         }
1539         dAtA[i] = 0x30
1540         i++
1541         i = encodeVarintGenerated(dAtA, i, uint64(m.Code))
1542         return i, nil
1543 }
1544
1545 func (m *StatusCause) Marshal() (dAtA []byte, err error) {
1546         size := m.Size()
1547         dAtA = make([]byte, size)
1548         n, err := m.MarshalTo(dAtA)
1549         if err != nil {
1550                 return nil, err
1551         }
1552         return dAtA[:n], nil
1553 }
1554
1555 func (m *StatusCause) MarshalTo(dAtA []byte) (int, error) {
1556         var i int
1557         _ = i
1558         var l int
1559         _ = l
1560         dAtA[i] = 0xa
1561         i++
1562         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1563         i += copy(dAtA[i:], m.Type)
1564         dAtA[i] = 0x12
1565         i++
1566         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1567         i += copy(dAtA[i:], m.Message)
1568         dAtA[i] = 0x1a
1569         i++
1570         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Field)))
1571         i += copy(dAtA[i:], m.Field)
1572         return i, nil
1573 }
1574
1575 func (m *StatusDetails) Marshal() (dAtA []byte, err error) {
1576         size := m.Size()
1577         dAtA = make([]byte, size)
1578         n, err := m.MarshalTo(dAtA)
1579         if err != nil {
1580                 return nil, err
1581         }
1582         return dAtA[:n], nil
1583 }
1584
1585 func (m *StatusDetails) MarshalTo(dAtA []byte) (int, error) {
1586         var i int
1587         _ = i
1588         var l int
1589         _ = l
1590         dAtA[i] = 0xa
1591         i++
1592         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1593         i += copy(dAtA[i:], m.Name)
1594         dAtA[i] = 0x12
1595         i++
1596         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
1597         i += copy(dAtA[i:], m.Group)
1598         dAtA[i] = 0x1a
1599         i++
1600         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1601         i += copy(dAtA[i:], m.Kind)
1602         if len(m.Causes) > 0 {
1603                 for _, msg := range m.Causes {
1604                         dAtA[i] = 0x22
1605                         i++
1606                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1607                         n, err := msg.MarshalTo(dAtA[i:])
1608                         if err != nil {
1609                                 return 0, err
1610                         }
1611                         i += n
1612                 }
1613         }
1614         dAtA[i] = 0x28
1615         i++
1616         i = encodeVarintGenerated(dAtA, i, uint64(m.RetryAfterSeconds))
1617         dAtA[i] = 0x32
1618         i++
1619         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1620         i += copy(dAtA[i:], m.UID)
1621         return i, nil
1622 }
1623
1624 func (m *Timestamp) Marshal() (dAtA []byte, err error) {
1625         size := m.Size()
1626         dAtA = make([]byte, size)
1627         n, err := m.MarshalTo(dAtA)
1628         if err != nil {
1629                 return nil, err
1630         }
1631         return dAtA[:n], nil
1632 }
1633
1634 func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) {
1635         var i int
1636         _ = i
1637         var l int
1638         _ = l
1639         dAtA[i] = 0x8
1640         i++
1641         i = encodeVarintGenerated(dAtA, i, uint64(m.Seconds))
1642         dAtA[i] = 0x10
1643         i++
1644         i = encodeVarintGenerated(dAtA, i, uint64(m.Nanos))
1645         return i, nil
1646 }
1647
1648 func (m *TypeMeta) Marshal() (dAtA []byte, err error) {
1649         size := m.Size()
1650         dAtA = make([]byte, size)
1651         n, err := m.MarshalTo(dAtA)
1652         if err != nil {
1653                 return nil, err
1654         }
1655         return dAtA[:n], nil
1656 }
1657
1658 func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) {
1659         var i int
1660         _ = i
1661         var l int
1662         _ = l
1663         dAtA[i] = 0xa
1664         i++
1665         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1666         i += copy(dAtA[i:], m.Kind)
1667         dAtA[i] = 0x12
1668         i++
1669         i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
1670         i += copy(dAtA[i:], m.APIVersion)
1671         return i, nil
1672 }
1673
1674 func (m *UpdateOptions) Marshal() (dAtA []byte, err error) {
1675         size := m.Size()
1676         dAtA = make([]byte, size)
1677         n, err := m.MarshalTo(dAtA)
1678         if err != nil {
1679                 return nil, err
1680         }
1681         return dAtA[:n], nil
1682 }
1683
1684 func (m *UpdateOptions) MarshalTo(dAtA []byte) (int, error) {
1685         var i int
1686         _ = i
1687         var l int
1688         _ = l
1689         if len(m.DryRun) > 0 {
1690                 for _, s := range m.DryRun {
1691                         dAtA[i] = 0xa
1692                         i++
1693                         l = len(s)
1694                         for l >= 1<<7 {
1695                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1696                                 l >>= 7
1697                                 i++
1698                         }
1699                         dAtA[i] = uint8(l)
1700                         i++
1701                         i += copy(dAtA[i:], s)
1702                 }
1703         }
1704         return i, nil
1705 }
1706
1707 func (m Verbs) Marshal() (dAtA []byte, err error) {
1708         size := m.Size()
1709         dAtA = make([]byte, size)
1710         n, err := m.MarshalTo(dAtA)
1711         if err != nil {
1712                 return nil, err
1713         }
1714         return dAtA[:n], nil
1715 }
1716
1717 func (m Verbs) MarshalTo(dAtA []byte) (int, error) {
1718         var i int
1719         _ = i
1720         var l int
1721         _ = l
1722         if len(m) > 0 {
1723                 for _, s := range m {
1724                         dAtA[i] = 0xa
1725                         i++
1726                         l = len(s)
1727                         for l >= 1<<7 {
1728                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1729                                 l >>= 7
1730                                 i++
1731                         }
1732                         dAtA[i] = uint8(l)
1733                         i++
1734                         i += copy(dAtA[i:], s)
1735                 }
1736         }
1737         return i, nil
1738 }
1739
1740 func (m *WatchEvent) Marshal() (dAtA []byte, err error) {
1741         size := m.Size()
1742         dAtA = make([]byte, size)
1743         n, err := m.MarshalTo(dAtA)
1744         if err != nil {
1745                 return nil, err
1746         }
1747         return dAtA[:n], nil
1748 }
1749
1750 func (m *WatchEvent) MarshalTo(dAtA []byte) (int, error) {
1751         var i int
1752         _ = i
1753         var l int
1754         _ = l
1755         dAtA[i] = 0xa
1756         i++
1757         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1758         i += copy(dAtA[i:], m.Type)
1759         dAtA[i] = 0x12
1760         i++
1761         i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size()))
1762         n11, err := m.Object.MarshalTo(dAtA[i:])
1763         if err != nil {
1764                 return 0, err
1765         }
1766         i += n11
1767         return i, nil
1768 }
1769
1770 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1771         for v >= 1<<7 {
1772                 dAtA[offset] = uint8(v&0x7f | 0x80)
1773                 v >>= 7
1774                 offset++
1775         }
1776         dAtA[offset] = uint8(v)
1777         return offset + 1
1778 }
1779 func (m *APIGroup) Size() (n int) {
1780         var l int
1781         _ = l
1782         l = len(m.Name)
1783         n += 1 + l + sovGenerated(uint64(l))
1784         if len(m.Versions) > 0 {
1785                 for _, e := range m.Versions {
1786                         l = e.Size()
1787                         n += 1 + l + sovGenerated(uint64(l))
1788                 }
1789         }
1790         l = m.PreferredVersion.Size()
1791         n += 1 + l + sovGenerated(uint64(l))
1792         if len(m.ServerAddressByClientCIDRs) > 0 {
1793                 for _, e := range m.ServerAddressByClientCIDRs {
1794                         l = e.Size()
1795                         n += 1 + l + sovGenerated(uint64(l))
1796                 }
1797         }
1798         return n
1799 }
1800
1801 func (m *APIGroupList) Size() (n int) {
1802         var l int
1803         _ = l
1804         if len(m.Groups) > 0 {
1805                 for _, e := range m.Groups {
1806                         l = e.Size()
1807                         n += 1 + l + sovGenerated(uint64(l))
1808                 }
1809         }
1810         return n
1811 }
1812
1813 func (m *APIResource) Size() (n int) {
1814         var l int
1815         _ = l
1816         l = len(m.Name)
1817         n += 1 + l + sovGenerated(uint64(l))
1818         n += 2
1819         l = len(m.Kind)
1820         n += 1 + l + sovGenerated(uint64(l))
1821         if m.Verbs != nil {
1822                 l = m.Verbs.Size()
1823                 n += 1 + l + sovGenerated(uint64(l))
1824         }
1825         if len(m.ShortNames) > 0 {
1826                 for _, s := range m.ShortNames {
1827                         l = len(s)
1828                         n += 1 + l + sovGenerated(uint64(l))
1829                 }
1830         }
1831         l = len(m.SingularName)
1832         n += 1 + l + sovGenerated(uint64(l))
1833         if len(m.Categories) > 0 {
1834                 for _, s := range m.Categories {
1835                         l = len(s)
1836                         n += 1 + l + sovGenerated(uint64(l))
1837                 }
1838         }
1839         l = len(m.Group)
1840         n += 1 + l + sovGenerated(uint64(l))
1841         l = len(m.Version)
1842         n += 1 + l + sovGenerated(uint64(l))
1843         return n
1844 }
1845
1846 func (m *APIResourceList) Size() (n int) {
1847         var l int
1848         _ = l
1849         l = len(m.GroupVersion)
1850         n += 1 + l + sovGenerated(uint64(l))
1851         if len(m.APIResources) > 0 {
1852                 for _, e := range m.APIResources {
1853                         l = e.Size()
1854                         n += 1 + l + sovGenerated(uint64(l))
1855                 }
1856         }
1857         return n
1858 }
1859
1860 func (m *APIVersions) Size() (n int) {
1861         var l int
1862         _ = l
1863         if len(m.Versions) > 0 {
1864                 for _, s := range m.Versions {
1865                         l = len(s)
1866                         n += 1 + l + sovGenerated(uint64(l))
1867                 }
1868         }
1869         if len(m.ServerAddressByClientCIDRs) > 0 {
1870                 for _, e := range m.ServerAddressByClientCIDRs {
1871                         l = e.Size()
1872                         n += 1 + l + sovGenerated(uint64(l))
1873                 }
1874         }
1875         return n
1876 }
1877
1878 func (m *CreateOptions) Size() (n int) {
1879         var l int
1880         _ = l
1881         if len(m.DryRun) > 0 {
1882                 for _, s := range m.DryRun {
1883                         l = len(s)
1884                         n += 1 + l + sovGenerated(uint64(l))
1885                 }
1886         }
1887         n += 2
1888         return n
1889 }
1890
1891 func (m *DeleteOptions) Size() (n int) {
1892         var l int
1893         _ = l
1894         if m.GracePeriodSeconds != nil {
1895                 n += 1 + sovGenerated(uint64(*m.GracePeriodSeconds))
1896         }
1897         if m.Preconditions != nil {
1898                 l = m.Preconditions.Size()
1899                 n += 1 + l + sovGenerated(uint64(l))
1900         }
1901         if m.OrphanDependents != nil {
1902                 n += 2
1903         }
1904         if m.PropagationPolicy != nil {
1905                 l = len(*m.PropagationPolicy)
1906                 n += 1 + l + sovGenerated(uint64(l))
1907         }
1908         if len(m.DryRun) > 0 {
1909                 for _, s := range m.DryRun {
1910                         l = len(s)
1911                         n += 1 + l + sovGenerated(uint64(l))
1912                 }
1913         }
1914         return n
1915 }
1916
1917 func (m *Duration) Size() (n int) {
1918         var l int
1919         _ = l
1920         n += 1 + sovGenerated(uint64(m.Duration))
1921         return n
1922 }
1923
1924 func (m *ExportOptions) Size() (n int) {
1925         var l int
1926         _ = l
1927         n += 2
1928         n += 2
1929         return n
1930 }
1931
1932 func (m *GetOptions) Size() (n int) {
1933         var l int
1934         _ = l
1935         l = len(m.ResourceVersion)
1936         n += 1 + l + sovGenerated(uint64(l))
1937         n += 2
1938         return n
1939 }
1940
1941 func (m *GroupKind) Size() (n int) {
1942         var l int
1943         _ = l
1944         l = len(m.Group)
1945         n += 1 + l + sovGenerated(uint64(l))
1946         l = len(m.Kind)
1947         n += 1 + l + sovGenerated(uint64(l))
1948         return n
1949 }
1950
1951 func (m *GroupResource) Size() (n int) {
1952         var l int
1953         _ = l
1954         l = len(m.Group)
1955         n += 1 + l + sovGenerated(uint64(l))
1956         l = len(m.Resource)
1957         n += 1 + l + sovGenerated(uint64(l))
1958         return n
1959 }
1960
1961 func (m *GroupVersion) Size() (n int) {
1962         var l int
1963         _ = l
1964         l = len(m.Group)
1965         n += 1 + l + sovGenerated(uint64(l))
1966         l = len(m.Version)
1967         n += 1 + l + sovGenerated(uint64(l))
1968         return n
1969 }
1970
1971 func (m *GroupVersionForDiscovery) Size() (n int) {
1972         var l int
1973         _ = l
1974         l = len(m.GroupVersion)
1975         n += 1 + l + sovGenerated(uint64(l))
1976         l = len(m.Version)
1977         n += 1 + l + sovGenerated(uint64(l))
1978         return n
1979 }
1980
1981 func (m *GroupVersionKind) Size() (n int) {
1982         var l int
1983         _ = l
1984         l = len(m.Group)
1985         n += 1 + l + sovGenerated(uint64(l))
1986         l = len(m.Version)
1987         n += 1 + l + sovGenerated(uint64(l))
1988         l = len(m.Kind)
1989         n += 1 + l + sovGenerated(uint64(l))
1990         return n
1991 }
1992
1993 func (m *GroupVersionResource) Size() (n int) {
1994         var l int
1995         _ = l
1996         l = len(m.Group)
1997         n += 1 + l + sovGenerated(uint64(l))
1998         l = len(m.Version)
1999         n += 1 + l + sovGenerated(uint64(l))
2000         l = len(m.Resource)
2001         n += 1 + l + sovGenerated(uint64(l))
2002         return n
2003 }
2004
2005 func (m *Initializer) Size() (n int) {
2006         var l int
2007         _ = l
2008         l = len(m.Name)
2009         n += 1 + l + sovGenerated(uint64(l))
2010         return n
2011 }
2012
2013 func (m *Initializers) Size() (n int) {
2014         var l int
2015         _ = l
2016         if len(m.Pending) > 0 {
2017                 for _, e := range m.Pending {
2018                         l = e.Size()
2019                         n += 1 + l + sovGenerated(uint64(l))
2020                 }
2021         }
2022         if m.Result != nil {
2023                 l = m.Result.Size()
2024                 n += 1 + l + sovGenerated(uint64(l))
2025         }
2026         return n
2027 }
2028
2029 func (m *LabelSelector) Size() (n int) {
2030         var l int
2031         _ = l
2032         if len(m.MatchLabels) > 0 {
2033                 for k, v := range m.MatchLabels {
2034                         _ = k
2035                         _ = v
2036                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2037                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2038                 }
2039         }
2040         if len(m.MatchExpressions) > 0 {
2041                 for _, e := range m.MatchExpressions {
2042                         l = e.Size()
2043                         n += 1 + l + sovGenerated(uint64(l))
2044                 }
2045         }
2046         return n
2047 }
2048
2049 func (m *LabelSelectorRequirement) Size() (n int) {
2050         var l int
2051         _ = l
2052         l = len(m.Key)
2053         n += 1 + l + sovGenerated(uint64(l))
2054         l = len(m.Operator)
2055         n += 1 + l + sovGenerated(uint64(l))
2056         if len(m.Values) > 0 {
2057                 for _, s := range m.Values {
2058                         l = len(s)
2059                         n += 1 + l + sovGenerated(uint64(l))
2060                 }
2061         }
2062         return n
2063 }
2064
2065 func (m *List) Size() (n int) {
2066         var l int
2067         _ = l
2068         l = m.ListMeta.Size()
2069         n += 1 + l + sovGenerated(uint64(l))
2070         if len(m.Items) > 0 {
2071                 for _, e := range m.Items {
2072                         l = e.Size()
2073                         n += 1 + l + sovGenerated(uint64(l))
2074                 }
2075         }
2076         return n
2077 }
2078
2079 func (m *ListMeta) Size() (n int) {
2080         var l int
2081         _ = l
2082         l = len(m.SelfLink)
2083         n += 1 + l + sovGenerated(uint64(l))
2084         l = len(m.ResourceVersion)
2085         n += 1 + l + sovGenerated(uint64(l))
2086         l = len(m.Continue)
2087         n += 1 + l + sovGenerated(uint64(l))
2088         return n
2089 }
2090
2091 func (m *ListOptions) Size() (n int) {
2092         var l int
2093         _ = l
2094         l = len(m.LabelSelector)
2095         n += 1 + l + sovGenerated(uint64(l))
2096         l = len(m.FieldSelector)
2097         n += 1 + l + sovGenerated(uint64(l))
2098         n += 2
2099         l = len(m.ResourceVersion)
2100         n += 1 + l + sovGenerated(uint64(l))
2101         if m.TimeoutSeconds != nil {
2102                 n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
2103         }
2104         n += 2
2105         n += 1 + sovGenerated(uint64(m.Limit))
2106         l = len(m.Continue)
2107         n += 1 + l + sovGenerated(uint64(l))
2108         return n
2109 }
2110
2111 func (m *ObjectMeta) Size() (n int) {
2112         var l int
2113         _ = l
2114         l = len(m.Name)
2115         n += 1 + l + sovGenerated(uint64(l))
2116         l = len(m.GenerateName)
2117         n += 1 + l + sovGenerated(uint64(l))
2118         l = len(m.Namespace)
2119         n += 1 + l + sovGenerated(uint64(l))
2120         l = len(m.SelfLink)
2121         n += 1 + l + sovGenerated(uint64(l))
2122         l = len(m.UID)
2123         n += 1 + l + sovGenerated(uint64(l))
2124         l = len(m.ResourceVersion)
2125         n += 1 + l + sovGenerated(uint64(l))
2126         n += 1 + sovGenerated(uint64(m.Generation))
2127         l = m.CreationTimestamp.Size()
2128         n += 1 + l + sovGenerated(uint64(l))
2129         if m.DeletionTimestamp != nil {
2130                 l = m.DeletionTimestamp.Size()
2131                 n += 1 + l + sovGenerated(uint64(l))
2132         }
2133         if m.DeletionGracePeriodSeconds != nil {
2134                 n += 1 + sovGenerated(uint64(*m.DeletionGracePeriodSeconds))
2135         }
2136         if len(m.Labels) > 0 {
2137                 for k, v := range m.Labels {
2138                         _ = k
2139                         _ = v
2140                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2141                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2142                 }
2143         }
2144         if len(m.Annotations) > 0 {
2145                 for k, v := range m.Annotations {
2146                         _ = k
2147                         _ = v
2148                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2149                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2150                 }
2151         }
2152         if len(m.OwnerReferences) > 0 {
2153                 for _, e := range m.OwnerReferences {
2154                         l = e.Size()
2155                         n += 1 + l + sovGenerated(uint64(l))
2156                 }
2157         }
2158         if len(m.Finalizers) > 0 {
2159                 for _, s := range m.Finalizers {
2160                         l = len(s)
2161                         n += 1 + l + sovGenerated(uint64(l))
2162                 }
2163         }
2164         l = len(m.ClusterName)
2165         n += 1 + l + sovGenerated(uint64(l))
2166         if m.Initializers != nil {
2167                 l = m.Initializers.Size()
2168                 n += 2 + l + sovGenerated(uint64(l))
2169         }
2170         return n
2171 }
2172
2173 func (m *OwnerReference) Size() (n int) {
2174         var l int
2175         _ = l
2176         l = len(m.Kind)
2177         n += 1 + l + sovGenerated(uint64(l))
2178         l = len(m.Name)
2179         n += 1 + l + sovGenerated(uint64(l))
2180         l = len(m.UID)
2181         n += 1 + l + sovGenerated(uint64(l))
2182         l = len(m.APIVersion)
2183         n += 1 + l + sovGenerated(uint64(l))
2184         if m.Controller != nil {
2185                 n += 2
2186         }
2187         if m.BlockOwnerDeletion != nil {
2188                 n += 2
2189         }
2190         return n
2191 }
2192
2193 func (m *Patch) Size() (n int) {
2194         var l int
2195         _ = l
2196         return n
2197 }
2198
2199 func (m *Preconditions) Size() (n int) {
2200         var l int
2201         _ = l
2202         if m.UID != nil {
2203                 l = len(*m.UID)
2204                 n += 1 + l + sovGenerated(uint64(l))
2205         }
2206         return n
2207 }
2208
2209 func (m *RootPaths) Size() (n int) {
2210         var l int
2211         _ = l
2212         if len(m.Paths) > 0 {
2213                 for _, s := range m.Paths {
2214                         l = len(s)
2215                         n += 1 + l + sovGenerated(uint64(l))
2216                 }
2217         }
2218         return n
2219 }
2220
2221 func (m *ServerAddressByClientCIDR) Size() (n int) {
2222         var l int
2223         _ = l
2224         l = len(m.ClientCIDR)
2225         n += 1 + l + sovGenerated(uint64(l))
2226         l = len(m.ServerAddress)
2227         n += 1 + l + sovGenerated(uint64(l))
2228         return n
2229 }
2230
2231 func (m *Status) Size() (n int) {
2232         var l int
2233         _ = l
2234         l = m.ListMeta.Size()
2235         n += 1 + l + sovGenerated(uint64(l))
2236         l = len(m.Status)
2237         n += 1 + l + sovGenerated(uint64(l))
2238         l = len(m.Message)
2239         n += 1 + l + sovGenerated(uint64(l))
2240         l = len(m.Reason)
2241         n += 1 + l + sovGenerated(uint64(l))
2242         if m.Details != nil {
2243                 l = m.Details.Size()
2244                 n += 1 + l + sovGenerated(uint64(l))
2245         }
2246         n += 1 + sovGenerated(uint64(m.Code))
2247         return n
2248 }
2249
2250 func (m *StatusCause) Size() (n int) {
2251         var l int
2252         _ = l
2253         l = len(m.Type)
2254         n += 1 + l + sovGenerated(uint64(l))
2255         l = len(m.Message)
2256         n += 1 + l + sovGenerated(uint64(l))
2257         l = len(m.Field)
2258         n += 1 + l + sovGenerated(uint64(l))
2259         return n
2260 }
2261
2262 func (m *StatusDetails) Size() (n int) {
2263         var l int
2264         _ = l
2265         l = len(m.Name)
2266         n += 1 + l + sovGenerated(uint64(l))
2267         l = len(m.Group)
2268         n += 1 + l + sovGenerated(uint64(l))
2269         l = len(m.Kind)
2270         n += 1 + l + sovGenerated(uint64(l))
2271         if len(m.Causes) > 0 {
2272                 for _, e := range m.Causes {
2273                         l = e.Size()
2274                         n += 1 + l + sovGenerated(uint64(l))
2275                 }
2276         }
2277         n += 1 + sovGenerated(uint64(m.RetryAfterSeconds))
2278         l = len(m.UID)
2279         n += 1 + l + sovGenerated(uint64(l))
2280         return n
2281 }
2282
2283 func (m *Timestamp) Size() (n int) {
2284         var l int
2285         _ = l
2286         n += 1 + sovGenerated(uint64(m.Seconds))
2287         n += 1 + sovGenerated(uint64(m.Nanos))
2288         return n
2289 }
2290
2291 func (m *TypeMeta) Size() (n int) {
2292         var l int
2293         _ = l
2294         l = len(m.Kind)
2295         n += 1 + l + sovGenerated(uint64(l))
2296         l = len(m.APIVersion)
2297         n += 1 + l + sovGenerated(uint64(l))
2298         return n
2299 }
2300
2301 func (m *UpdateOptions) Size() (n int) {
2302         var l int
2303         _ = l
2304         if len(m.DryRun) > 0 {
2305                 for _, s := range m.DryRun {
2306                         l = len(s)
2307                         n += 1 + l + sovGenerated(uint64(l))
2308                 }
2309         }
2310         return n
2311 }
2312
2313 func (m Verbs) Size() (n int) {
2314         var l int
2315         _ = l
2316         if len(m) > 0 {
2317                 for _, s := range m {
2318                         l = len(s)
2319                         n += 1 + l + sovGenerated(uint64(l))
2320                 }
2321         }
2322         return n
2323 }
2324
2325 func (m *WatchEvent) Size() (n int) {
2326         var l int
2327         _ = l
2328         l = len(m.Type)
2329         n += 1 + l + sovGenerated(uint64(l))
2330         l = m.Object.Size()
2331         n += 1 + l + sovGenerated(uint64(l))
2332         return n
2333 }
2334
2335 func sovGenerated(x uint64) (n int) {
2336         for {
2337                 n++
2338                 x >>= 7
2339                 if x == 0 {
2340                         break
2341                 }
2342         }
2343         return n
2344 }
2345 func sozGenerated(x uint64) (n int) {
2346         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2347 }
2348 func (this *APIGroup) String() string {
2349         if this == nil {
2350                 return "nil"
2351         }
2352         s := strings.Join([]string{`&APIGroup{`,
2353                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2354                 `Versions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Versions), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`,
2355                 `PreferredVersion:` + strings.Replace(strings.Replace(this.PreferredVersion.String(), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`,
2356                 `ServerAddressByClientCIDRs:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServerAddressByClientCIDRs), "ServerAddressByClientCIDR", "ServerAddressByClientCIDR", 1), `&`, ``, 1) + `,`,
2357                 `}`,
2358         }, "")
2359         return s
2360 }
2361 func (this *APIGroupList) String() string {
2362         if this == nil {
2363                 return "nil"
2364         }
2365         s := strings.Join([]string{`&APIGroupList{`,
2366                 `Groups:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Groups), "APIGroup", "APIGroup", 1), `&`, ``, 1) + `,`,
2367                 `}`,
2368         }, "")
2369         return s
2370 }
2371 func (this *APIResource) String() string {
2372         if this == nil {
2373                 return "nil"
2374         }
2375         s := strings.Join([]string{`&APIResource{`,
2376                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2377                 `Namespaced:` + fmt.Sprintf("%v", this.Namespaced) + `,`,
2378                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2379                 `Verbs:` + strings.Replace(fmt.Sprintf("%v", this.Verbs), "Verbs", "Verbs", 1) + `,`,
2380                 `ShortNames:` + fmt.Sprintf("%v", this.ShortNames) + `,`,
2381                 `SingularName:` + fmt.Sprintf("%v", this.SingularName) + `,`,
2382                 `Categories:` + fmt.Sprintf("%v", this.Categories) + `,`,
2383                 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
2384                 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
2385                 `}`,
2386         }, "")
2387         return s
2388 }
2389 func (this *APIResourceList) String() string {
2390         if this == nil {
2391                 return "nil"
2392         }
2393         s := strings.Join([]string{`&APIResourceList{`,
2394                 `GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`,
2395                 `APIResources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.APIResources), "APIResource", "APIResource", 1), `&`, ``, 1) + `,`,
2396                 `}`,
2397         }, "")
2398         return s
2399 }
2400 func (this *CreateOptions) String() string {
2401         if this == nil {
2402                 return "nil"
2403         }
2404         s := strings.Join([]string{`&CreateOptions{`,
2405                 `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
2406                 `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`,
2407                 `}`,
2408         }, "")
2409         return s
2410 }
2411 func (this *DeleteOptions) String() string {
2412         if this == nil {
2413                 return "nil"
2414         }
2415         s := strings.Join([]string{`&DeleteOptions{`,
2416                 `GracePeriodSeconds:` + valueToStringGenerated(this.GracePeriodSeconds) + `,`,
2417                 `Preconditions:` + strings.Replace(fmt.Sprintf("%v", this.Preconditions), "Preconditions", "Preconditions", 1) + `,`,
2418                 `OrphanDependents:` + valueToStringGenerated(this.OrphanDependents) + `,`,
2419                 `PropagationPolicy:` + valueToStringGenerated(this.PropagationPolicy) + `,`,
2420                 `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
2421                 `}`,
2422         }, "")
2423         return s
2424 }
2425 func (this *Duration) String() string {
2426         if this == nil {
2427                 return "nil"
2428         }
2429         s := strings.Join([]string{`&Duration{`,
2430                 `Duration:` + fmt.Sprintf("%v", this.Duration) + `,`,
2431                 `}`,
2432         }, "")
2433         return s
2434 }
2435 func (this *ExportOptions) String() string {
2436         if this == nil {
2437                 return "nil"
2438         }
2439         s := strings.Join([]string{`&ExportOptions{`,
2440                 `Export:` + fmt.Sprintf("%v", this.Export) + `,`,
2441                 `Exact:` + fmt.Sprintf("%v", this.Exact) + `,`,
2442                 `}`,
2443         }, "")
2444         return s
2445 }
2446 func (this *GetOptions) String() string {
2447         if this == nil {
2448                 return "nil"
2449         }
2450         s := strings.Join([]string{`&GetOptions{`,
2451                 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2452                 `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`,
2453                 `}`,
2454         }, "")
2455         return s
2456 }
2457 func (this *GroupVersionForDiscovery) String() string {
2458         if this == nil {
2459                 return "nil"
2460         }
2461         s := strings.Join([]string{`&GroupVersionForDiscovery{`,
2462                 `GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`,
2463                 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
2464                 `}`,
2465         }, "")
2466         return s
2467 }
2468 func (this *Initializer) String() string {
2469         if this == nil {
2470                 return "nil"
2471         }
2472         s := strings.Join([]string{`&Initializer{`,
2473                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2474                 `}`,
2475         }, "")
2476         return s
2477 }
2478 func (this *Initializers) String() string {
2479         if this == nil {
2480                 return "nil"
2481         }
2482         s := strings.Join([]string{`&Initializers{`,
2483                 `Pending:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Pending), "Initializer", "Initializer", 1), `&`, ``, 1) + `,`,
2484                 `Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Status", "Status", 1) + `,`,
2485                 `}`,
2486         }, "")
2487         return s
2488 }
2489 func (this *LabelSelector) String() string {
2490         if this == nil {
2491                 return "nil"
2492         }
2493         keysForMatchLabels := make([]string, 0, len(this.MatchLabels))
2494         for k := range this.MatchLabels {
2495                 keysForMatchLabels = append(keysForMatchLabels, k)
2496         }
2497         github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
2498         mapStringForMatchLabels := "map[string]string{"
2499         for _, k := range keysForMatchLabels {
2500                 mapStringForMatchLabels += fmt.Sprintf("%v: %v,", k, this.MatchLabels[k])
2501         }
2502         mapStringForMatchLabels += "}"
2503         s := strings.Join([]string{`&LabelSelector{`,
2504                 `MatchLabels:` + mapStringForMatchLabels + `,`,
2505                 `MatchExpressions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.MatchExpressions), "LabelSelectorRequirement", "LabelSelectorRequirement", 1), `&`, ``, 1) + `,`,
2506                 `}`,
2507         }, "")
2508         return s
2509 }
2510 func (this *LabelSelectorRequirement) String() string {
2511         if this == nil {
2512                 return "nil"
2513         }
2514         s := strings.Join([]string{`&LabelSelectorRequirement{`,
2515                 `Key:` + fmt.Sprintf("%v", this.Key) + `,`,
2516                 `Operator:` + fmt.Sprintf("%v", this.Operator) + `,`,
2517                 `Values:` + fmt.Sprintf("%v", this.Values) + `,`,
2518                 `}`,
2519         }, "")
2520         return s
2521 }
2522 func (this *List) String() string {
2523         if this == nil {
2524                 return "nil"
2525         }
2526         s := strings.Join([]string{`&List{`,
2527                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
2528                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2529                 `}`,
2530         }, "")
2531         return s
2532 }
2533 func (this *ListMeta) String() string {
2534         if this == nil {
2535                 return "nil"
2536         }
2537         s := strings.Join([]string{`&ListMeta{`,
2538                 `SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`,
2539                 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2540                 `Continue:` + fmt.Sprintf("%v", this.Continue) + `,`,
2541                 `}`,
2542         }, "")
2543         return s
2544 }
2545 func (this *ListOptions) String() string {
2546         if this == nil {
2547                 return "nil"
2548         }
2549         s := strings.Join([]string{`&ListOptions{`,
2550                 `LabelSelector:` + fmt.Sprintf("%v", this.LabelSelector) + `,`,
2551                 `FieldSelector:` + fmt.Sprintf("%v", this.FieldSelector) + `,`,
2552                 `Watch:` + fmt.Sprintf("%v", this.Watch) + `,`,
2553                 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2554                 `TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
2555                 `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`,
2556                 `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
2557                 `Continue:` + fmt.Sprintf("%v", this.Continue) + `,`,
2558                 `}`,
2559         }, "")
2560         return s
2561 }
2562 func (this *ObjectMeta) String() string {
2563         if this == nil {
2564                 return "nil"
2565         }
2566         keysForLabels := make([]string, 0, len(this.Labels))
2567         for k := range this.Labels {
2568                 keysForLabels = append(keysForLabels, k)
2569         }
2570         github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
2571         mapStringForLabels := "map[string]string{"
2572         for _, k := range keysForLabels {
2573                 mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
2574         }
2575         mapStringForLabels += "}"
2576         keysForAnnotations := make([]string, 0, len(this.Annotations))
2577         for k := range this.Annotations {
2578                 keysForAnnotations = append(keysForAnnotations, k)
2579         }
2580         github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
2581         mapStringForAnnotations := "map[string]string{"
2582         for _, k := range keysForAnnotations {
2583                 mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
2584         }
2585         mapStringForAnnotations += "}"
2586         s := strings.Join([]string{`&ObjectMeta{`,
2587                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2588                 `GenerateName:` + fmt.Sprintf("%v", this.GenerateName) + `,`,
2589                 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
2590                 `SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`,
2591                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2592                 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2593                 `Generation:` + fmt.Sprintf("%v", this.Generation) + `,`,
2594                 `CreationTimestamp:` + strings.Replace(strings.Replace(this.CreationTimestamp.String(), "Time", "Time", 1), `&`, ``, 1) + `,`,
2595                 `DeletionTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.DeletionTimestamp), "Time", "Time", 1) + `,`,
2596                 `DeletionGracePeriodSeconds:` + valueToStringGenerated(this.DeletionGracePeriodSeconds) + `,`,
2597                 `Labels:` + mapStringForLabels + `,`,
2598                 `Annotations:` + mapStringForAnnotations + `,`,
2599                 `OwnerReferences:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OwnerReferences), "OwnerReference", "OwnerReference", 1), `&`, ``, 1) + `,`,
2600                 `Finalizers:` + fmt.Sprintf("%v", this.Finalizers) + `,`,
2601                 `ClusterName:` + fmt.Sprintf("%v", this.ClusterName) + `,`,
2602                 `Initializers:` + strings.Replace(fmt.Sprintf("%v", this.Initializers), "Initializers", "Initializers", 1) + `,`,
2603                 `}`,
2604         }, "")
2605         return s
2606 }
2607 func (this *OwnerReference) String() string {
2608         if this == nil {
2609                 return "nil"
2610         }
2611         s := strings.Join([]string{`&OwnerReference{`,
2612                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2613                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2614                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2615                 `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
2616                 `Controller:` + valueToStringGenerated(this.Controller) + `,`,
2617                 `BlockOwnerDeletion:` + valueToStringGenerated(this.BlockOwnerDeletion) + `,`,
2618                 `}`,
2619         }, "")
2620         return s
2621 }
2622 func (this *Patch) String() string {
2623         if this == nil {
2624                 return "nil"
2625         }
2626         s := strings.Join([]string{`&Patch{`,
2627                 `}`,
2628         }, "")
2629         return s
2630 }
2631 func (this *Preconditions) String() string {
2632         if this == nil {
2633                 return "nil"
2634         }
2635         s := strings.Join([]string{`&Preconditions{`,
2636                 `UID:` + valueToStringGenerated(this.UID) + `,`,
2637                 `}`,
2638         }, "")
2639         return s
2640 }
2641 func (this *RootPaths) String() string {
2642         if this == nil {
2643                 return "nil"
2644         }
2645         s := strings.Join([]string{`&RootPaths{`,
2646                 `Paths:` + fmt.Sprintf("%v", this.Paths) + `,`,
2647                 `}`,
2648         }, "")
2649         return s
2650 }
2651 func (this *ServerAddressByClientCIDR) String() string {
2652         if this == nil {
2653                 return "nil"
2654         }
2655         s := strings.Join([]string{`&ServerAddressByClientCIDR{`,
2656                 `ClientCIDR:` + fmt.Sprintf("%v", this.ClientCIDR) + `,`,
2657                 `ServerAddress:` + fmt.Sprintf("%v", this.ServerAddress) + `,`,
2658                 `}`,
2659         }, "")
2660         return s
2661 }
2662 func (this *Status) String() string {
2663         if this == nil {
2664                 return "nil"
2665         }
2666         s := strings.Join([]string{`&Status{`,
2667                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
2668                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2669                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2670                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2671                 `Details:` + strings.Replace(fmt.Sprintf("%v", this.Details), "StatusDetails", "StatusDetails", 1) + `,`,
2672                 `Code:` + fmt.Sprintf("%v", this.Code) + `,`,
2673                 `}`,
2674         }, "")
2675         return s
2676 }
2677 func (this *StatusCause) String() string {
2678         if this == nil {
2679                 return "nil"
2680         }
2681         s := strings.Join([]string{`&StatusCause{`,
2682                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2683                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2684                 `Field:` + fmt.Sprintf("%v", this.Field) + `,`,
2685                 `}`,
2686         }, "")
2687         return s
2688 }
2689 func (this *StatusDetails) String() string {
2690         if this == nil {
2691                 return "nil"
2692         }
2693         s := strings.Join([]string{`&StatusDetails{`,
2694                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2695                 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
2696                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2697                 `Causes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Causes), "StatusCause", "StatusCause", 1), `&`, ``, 1) + `,`,
2698                 `RetryAfterSeconds:` + fmt.Sprintf("%v", this.RetryAfterSeconds) + `,`,
2699                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2700                 `}`,
2701         }, "")
2702         return s
2703 }
2704 func (this *Timestamp) String() string {
2705         if this == nil {
2706                 return "nil"
2707         }
2708         s := strings.Join([]string{`&Timestamp{`,
2709                 `Seconds:` + fmt.Sprintf("%v", this.Seconds) + `,`,
2710                 `Nanos:` + fmt.Sprintf("%v", this.Nanos) + `,`,
2711                 `}`,
2712         }, "")
2713         return s
2714 }
2715 func (this *TypeMeta) String() string {
2716         if this == nil {
2717                 return "nil"
2718         }
2719         s := strings.Join([]string{`&TypeMeta{`,
2720                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2721                 `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
2722                 `}`,
2723         }, "")
2724         return s
2725 }
2726 func (this *UpdateOptions) String() string {
2727         if this == nil {
2728                 return "nil"
2729         }
2730         s := strings.Join([]string{`&UpdateOptions{`,
2731                 `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
2732                 `}`,
2733         }, "")
2734         return s
2735 }
2736 func (this *WatchEvent) String() string {
2737         if this == nil {
2738                 return "nil"
2739         }
2740         s := strings.Join([]string{`&WatchEvent{`,
2741                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2742                 `Object:` + strings.Replace(strings.Replace(this.Object.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2743                 `}`,
2744         }, "")
2745         return s
2746 }
2747 func valueToStringGenerated(v interface{}) string {
2748         rv := reflect.ValueOf(v)
2749         if rv.IsNil() {
2750                 return "nil"
2751         }
2752         pv := reflect.Indirect(rv).Interface()
2753         return fmt.Sprintf("*%v", pv)
2754 }
2755 func (m *APIGroup) Unmarshal(dAtA []byte) error {
2756         l := len(dAtA)
2757         iNdEx := 0
2758         for iNdEx < l {
2759                 preIndex := iNdEx
2760                 var wire uint64
2761                 for shift := uint(0); ; shift += 7 {
2762                         if shift >= 64 {
2763                                 return ErrIntOverflowGenerated
2764                         }
2765                         if iNdEx >= l {
2766                                 return io.ErrUnexpectedEOF
2767                         }
2768                         b := dAtA[iNdEx]
2769                         iNdEx++
2770                         wire |= (uint64(b) & 0x7F) << shift
2771                         if b < 0x80 {
2772                                 break
2773                         }
2774                 }
2775                 fieldNum := int32(wire >> 3)
2776                 wireType := int(wire & 0x7)
2777                 if wireType == 4 {
2778                         return fmt.Errorf("proto: APIGroup: wiretype end group for non-group")
2779                 }
2780                 if fieldNum <= 0 {
2781                         return fmt.Errorf("proto: APIGroup: illegal tag %d (wire type %d)", fieldNum, wire)
2782                 }
2783                 switch fieldNum {
2784                 case 1:
2785                         if wireType != 2 {
2786                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
2787                         }
2788                         var stringLen uint64
2789                         for shift := uint(0); ; shift += 7 {
2790                                 if shift >= 64 {
2791                                         return ErrIntOverflowGenerated
2792                                 }
2793                                 if iNdEx >= l {
2794                                         return io.ErrUnexpectedEOF
2795                                 }
2796                                 b := dAtA[iNdEx]
2797                                 iNdEx++
2798                                 stringLen |= (uint64(b) & 0x7F) << shift
2799                                 if b < 0x80 {
2800                                         break
2801                                 }
2802                         }
2803                         intStringLen := int(stringLen)
2804                         if intStringLen < 0 {
2805                                 return ErrInvalidLengthGenerated
2806                         }
2807                         postIndex := iNdEx + intStringLen
2808                         if postIndex > l {
2809                                 return io.ErrUnexpectedEOF
2810                         }
2811                         m.Name = string(dAtA[iNdEx:postIndex])
2812                         iNdEx = postIndex
2813                 case 2:
2814                         if wireType != 2 {
2815                                 return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
2816                         }
2817                         var msglen int
2818                         for shift := uint(0); ; shift += 7 {
2819                                 if shift >= 64 {
2820                                         return ErrIntOverflowGenerated
2821                                 }
2822                                 if iNdEx >= l {
2823                                         return io.ErrUnexpectedEOF
2824                                 }
2825                                 b := dAtA[iNdEx]
2826                                 iNdEx++
2827                                 msglen |= (int(b) & 0x7F) << shift
2828                                 if b < 0x80 {
2829                                         break
2830                                 }
2831                         }
2832                         if msglen < 0 {
2833                                 return ErrInvalidLengthGenerated
2834                         }
2835                         postIndex := iNdEx + msglen
2836                         if postIndex > l {
2837                                 return io.ErrUnexpectedEOF
2838                         }
2839                         m.Versions = append(m.Versions, GroupVersionForDiscovery{})
2840                         if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2841                                 return err
2842                         }
2843                         iNdEx = postIndex
2844                 case 3:
2845                         if wireType != 2 {
2846                                 return fmt.Errorf("proto: wrong wireType = %d for field PreferredVersion", wireType)
2847                         }
2848                         var msglen int
2849                         for shift := uint(0); ; shift += 7 {
2850                                 if shift >= 64 {
2851                                         return ErrIntOverflowGenerated
2852                                 }
2853                                 if iNdEx >= l {
2854                                         return io.ErrUnexpectedEOF
2855                                 }
2856                                 b := dAtA[iNdEx]
2857                                 iNdEx++
2858                                 msglen |= (int(b) & 0x7F) << shift
2859                                 if b < 0x80 {
2860                                         break
2861                                 }
2862                         }
2863                         if msglen < 0 {
2864                                 return ErrInvalidLengthGenerated
2865                         }
2866                         postIndex := iNdEx + msglen
2867                         if postIndex > l {
2868                                 return io.ErrUnexpectedEOF
2869                         }
2870                         if err := m.PreferredVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2871                                 return err
2872                         }
2873                         iNdEx = postIndex
2874                 case 4:
2875                         if wireType != 2 {
2876                                 return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
2877                         }
2878                         var msglen int
2879                         for shift := uint(0); ; shift += 7 {
2880                                 if shift >= 64 {
2881                                         return ErrIntOverflowGenerated
2882                                 }
2883                                 if iNdEx >= l {
2884                                         return io.ErrUnexpectedEOF
2885                                 }
2886                                 b := dAtA[iNdEx]
2887                                 iNdEx++
2888                                 msglen |= (int(b) & 0x7F) << shift
2889                                 if b < 0x80 {
2890                                         break
2891                                 }
2892                         }
2893                         if msglen < 0 {
2894                                 return ErrInvalidLengthGenerated
2895                         }
2896                         postIndex := iNdEx + msglen
2897                         if postIndex > l {
2898                                 return io.ErrUnexpectedEOF
2899                         }
2900                         m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
2901                         if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2902                                 return err
2903                         }
2904                         iNdEx = postIndex
2905                 default:
2906                         iNdEx = preIndex
2907                         skippy, err := skipGenerated(dAtA[iNdEx:])
2908                         if err != nil {
2909                                 return err
2910                         }
2911                         if skippy < 0 {
2912                                 return ErrInvalidLengthGenerated
2913                         }
2914                         if (iNdEx + skippy) > l {
2915                                 return io.ErrUnexpectedEOF
2916                         }
2917                         iNdEx += skippy
2918                 }
2919         }
2920
2921         if iNdEx > l {
2922                 return io.ErrUnexpectedEOF
2923         }
2924         return nil
2925 }
2926 func (m *APIGroupList) Unmarshal(dAtA []byte) error {
2927         l := len(dAtA)
2928         iNdEx := 0
2929         for iNdEx < l {
2930                 preIndex := iNdEx
2931                 var wire uint64
2932                 for shift := uint(0); ; shift += 7 {
2933                         if shift >= 64 {
2934                                 return ErrIntOverflowGenerated
2935                         }
2936                         if iNdEx >= l {
2937                                 return io.ErrUnexpectedEOF
2938                         }
2939                         b := dAtA[iNdEx]
2940                         iNdEx++
2941                         wire |= (uint64(b) & 0x7F) << shift
2942                         if b < 0x80 {
2943                                 break
2944                         }
2945                 }
2946                 fieldNum := int32(wire >> 3)
2947                 wireType := int(wire & 0x7)
2948                 if wireType == 4 {
2949                         return fmt.Errorf("proto: APIGroupList: wiretype end group for non-group")
2950                 }
2951                 if fieldNum <= 0 {
2952                         return fmt.Errorf("proto: APIGroupList: illegal tag %d (wire type %d)", fieldNum, wire)
2953                 }
2954                 switch fieldNum {
2955                 case 1:
2956                         if wireType != 2 {
2957                                 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
2958                         }
2959                         var msglen int
2960                         for shift := uint(0); ; shift += 7 {
2961                                 if shift >= 64 {
2962                                         return ErrIntOverflowGenerated
2963                                 }
2964                                 if iNdEx >= l {
2965                                         return io.ErrUnexpectedEOF
2966                                 }
2967                                 b := dAtA[iNdEx]
2968                                 iNdEx++
2969                                 msglen |= (int(b) & 0x7F) << shift
2970                                 if b < 0x80 {
2971                                         break
2972                                 }
2973                         }
2974                         if msglen < 0 {
2975                                 return ErrInvalidLengthGenerated
2976                         }
2977                         postIndex := iNdEx + msglen
2978                         if postIndex > l {
2979                                 return io.ErrUnexpectedEOF
2980                         }
2981                         m.Groups = append(m.Groups, APIGroup{})
2982                         if err := m.Groups[len(m.Groups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2983                                 return err
2984                         }
2985                         iNdEx = postIndex
2986                 default:
2987                         iNdEx = preIndex
2988                         skippy, err := skipGenerated(dAtA[iNdEx:])
2989                         if err != nil {
2990                                 return err
2991                         }
2992                         if skippy < 0 {
2993                                 return ErrInvalidLengthGenerated
2994                         }
2995                         if (iNdEx + skippy) > l {
2996                                 return io.ErrUnexpectedEOF
2997                         }
2998                         iNdEx += skippy
2999                 }
3000         }
3001
3002         if iNdEx > l {
3003                 return io.ErrUnexpectedEOF
3004         }
3005         return nil
3006 }
3007 func (m *APIResource) Unmarshal(dAtA []byte) error {
3008         l := len(dAtA)
3009         iNdEx := 0
3010         for iNdEx < l {
3011                 preIndex := iNdEx
3012                 var wire uint64
3013                 for shift := uint(0); ; shift += 7 {
3014                         if shift >= 64 {
3015                                 return ErrIntOverflowGenerated
3016                         }
3017                         if iNdEx >= l {
3018                                 return io.ErrUnexpectedEOF
3019                         }
3020                         b := dAtA[iNdEx]
3021                         iNdEx++
3022                         wire |= (uint64(b) & 0x7F) << shift
3023                         if b < 0x80 {
3024                                 break
3025                         }
3026                 }
3027                 fieldNum := int32(wire >> 3)
3028                 wireType := int(wire & 0x7)
3029                 if wireType == 4 {
3030                         return fmt.Errorf("proto: APIResource: wiretype end group for non-group")
3031                 }
3032                 if fieldNum <= 0 {
3033                         return fmt.Errorf("proto: APIResource: illegal tag %d (wire type %d)", fieldNum, wire)
3034                 }
3035                 switch fieldNum {
3036                 case 1:
3037                         if wireType != 2 {
3038                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
3039                         }
3040                         var stringLen uint64
3041                         for shift := uint(0); ; shift += 7 {
3042                                 if shift >= 64 {
3043                                         return ErrIntOverflowGenerated
3044                                 }
3045                                 if iNdEx >= l {
3046                                         return io.ErrUnexpectedEOF
3047                                 }
3048                                 b := dAtA[iNdEx]
3049                                 iNdEx++
3050                                 stringLen |= (uint64(b) & 0x7F) << shift
3051                                 if b < 0x80 {
3052                                         break
3053                                 }
3054                         }
3055                         intStringLen := int(stringLen)
3056                         if intStringLen < 0 {
3057                                 return ErrInvalidLengthGenerated
3058                         }
3059                         postIndex := iNdEx + intStringLen
3060                         if postIndex > l {
3061                                 return io.ErrUnexpectedEOF
3062                         }
3063                         m.Name = string(dAtA[iNdEx:postIndex])
3064                         iNdEx = postIndex
3065                 case 2:
3066                         if wireType != 0 {
3067                                 return fmt.Errorf("proto: wrong wireType = %d for field Namespaced", wireType)
3068                         }
3069                         var v int
3070                         for shift := uint(0); ; shift += 7 {
3071                                 if shift >= 64 {
3072                                         return ErrIntOverflowGenerated
3073                                 }
3074                                 if iNdEx >= l {
3075                                         return io.ErrUnexpectedEOF
3076                                 }
3077                                 b := dAtA[iNdEx]
3078                                 iNdEx++
3079                                 v |= (int(b) & 0x7F) << shift
3080                                 if b < 0x80 {
3081                                         break
3082                                 }
3083                         }
3084                         m.Namespaced = bool(v != 0)
3085                 case 3:
3086                         if wireType != 2 {
3087                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
3088                         }
3089                         var stringLen uint64
3090                         for shift := uint(0); ; shift += 7 {
3091                                 if shift >= 64 {
3092                                         return ErrIntOverflowGenerated
3093                                 }
3094                                 if iNdEx >= l {
3095                                         return io.ErrUnexpectedEOF
3096                                 }
3097                                 b := dAtA[iNdEx]
3098                                 iNdEx++
3099                                 stringLen |= (uint64(b) & 0x7F) << shift
3100                                 if b < 0x80 {
3101                                         break
3102                                 }
3103                         }
3104                         intStringLen := int(stringLen)
3105                         if intStringLen < 0 {
3106                                 return ErrInvalidLengthGenerated
3107                         }
3108                         postIndex := iNdEx + intStringLen
3109                         if postIndex > l {
3110                                 return io.ErrUnexpectedEOF
3111                         }
3112                         m.Kind = string(dAtA[iNdEx:postIndex])
3113                         iNdEx = postIndex
3114                 case 4:
3115                         if wireType != 2 {
3116                                 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
3117                         }
3118                         var msglen int
3119                         for shift := uint(0); ; shift += 7 {
3120                                 if shift >= 64 {
3121                                         return ErrIntOverflowGenerated
3122                                 }
3123                                 if iNdEx >= l {
3124                                         return io.ErrUnexpectedEOF
3125                                 }
3126                                 b := dAtA[iNdEx]
3127                                 iNdEx++
3128                                 msglen |= (int(b) & 0x7F) << shift
3129                                 if b < 0x80 {
3130                                         break
3131                                 }
3132                         }
3133                         if msglen < 0 {
3134                                 return ErrInvalidLengthGenerated
3135                         }
3136                         postIndex := iNdEx + msglen
3137                         if postIndex > l {
3138                                 return io.ErrUnexpectedEOF
3139                         }
3140                         if m.Verbs == nil {
3141                                 m.Verbs = Verbs{}
3142                         }
3143                         if err := m.Verbs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3144                                 return err
3145                         }
3146                         iNdEx = postIndex
3147                 case 5:
3148                         if wireType != 2 {
3149                                 return fmt.Errorf("proto: wrong wireType = %d for field ShortNames", wireType)
3150                         }
3151                         var stringLen uint64
3152                         for shift := uint(0); ; shift += 7 {
3153                                 if shift >= 64 {
3154                                         return ErrIntOverflowGenerated
3155                                 }
3156                                 if iNdEx >= l {
3157                                         return io.ErrUnexpectedEOF
3158                                 }
3159                                 b := dAtA[iNdEx]
3160                                 iNdEx++
3161                                 stringLen |= (uint64(b) & 0x7F) << shift
3162                                 if b < 0x80 {
3163                                         break
3164                                 }
3165                         }
3166                         intStringLen := int(stringLen)
3167                         if intStringLen < 0 {
3168                                 return ErrInvalidLengthGenerated
3169                         }
3170                         postIndex := iNdEx + intStringLen
3171                         if postIndex > l {
3172                                 return io.ErrUnexpectedEOF
3173                         }
3174                         m.ShortNames = append(m.ShortNames, string(dAtA[iNdEx:postIndex]))
3175                         iNdEx = postIndex
3176                 case 6:
3177                         if wireType != 2 {
3178                                 return fmt.Errorf("proto: wrong wireType = %d for field SingularName", wireType)
3179                         }
3180                         var stringLen uint64
3181                         for shift := uint(0); ; shift += 7 {
3182                                 if shift >= 64 {
3183                                         return ErrIntOverflowGenerated
3184                                 }
3185                                 if iNdEx >= l {
3186                                         return io.ErrUnexpectedEOF
3187                                 }
3188                                 b := dAtA[iNdEx]
3189                                 iNdEx++
3190                                 stringLen |= (uint64(b) & 0x7F) << shift
3191                                 if b < 0x80 {
3192                                         break
3193                                 }
3194                         }
3195                         intStringLen := int(stringLen)
3196                         if intStringLen < 0 {
3197                                 return ErrInvalidLengthGenerated
3198                         }
3199                         postIndex := iNdEx + intStringLen
3200                         if postIndex > l {
3201                                 return io.ErrUnexpectedEOF
3202                         }
3203                         m.SingularName = string(dAtA[iNdEx:postIndex])
3204                         iNdEx = postIndex
3205                 case 7:
3206                         if wireType != 2 {
3207                                 return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType)
3208                         }
3209                         var stringLen uint64
3210                         for shift := uint(0); ; shift += 7 {
3211                                 if shift >= 64 {
3212                                         return ErrIntOverflowGenerated
3213                                 }
3214                                 if iNdEx >= l {
3215                                         return io.ErrUnexpectedEOF
3216                                 }
3217                                 b := dAtA[iNdEx]
3218                                 iNdEx++
3219                                 stringLen |= (uint64(b) & 0x7F) << shift
3220                                 if b < 0x80 {
3221                                         break
3222                                 }
3223                         }
3224                         intStringLen := int(stringLen)
3225                         if intStringLen < 0 {
3226                                 return ErrInvalidLengthGenerated
3227                         }
3228                         postIndex := iNdEx + intStringLen
3229                         if postIndex > l {
3230                                 return io.ErrUnexpectedEOF
3231                         }
3232                         m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex]))
3233                         iNdEx = postIndex
3234                 case 8:
3235                         if wireType != 2 {
3236                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
3237                         }
3238                         var stringLen uint64
3239                         for shift := uint(0); ; shift += 7 {
3240                                 if shift >= 64 {
3241                                         return ErrIntOverflowGenerated
3242                                 }
3243                                 if iNdEx >= l {
3244                                         return io.ErrUnexpectedEOF
3245                                 }
3246                                 b := dAtA[iNdEx]
3247                                 iNdEx++
3248                                 stringLen |= (uint64(b) & 0x7F) << shift
3249                                 if b < 0x80 {
3250                                         break
3251                                 }
3252                         }
3253                         intStringLen := int(stringLen)
3254                         if intStringLen < 0 {
3255                                 return ErrInvalidLengthGenerated
3256                         }
3257                         postIndex := iNdEx + intStringLen
3258                         if postIndex > l {
3259                                 return io.ErrUnexpectedEOF
3260                         }
3261                         m.Group = string(dAtA[iNdEx:postIndex])
3262                         iNdEx = postIndex
3263                 case 9:
3264                         if wireType != 2 {
3265                                 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
3266                         }
3267                         var stringLen uint64
3268                         for shift := uint(0); ; shift += 7 {
3269                                 if shift >= 64 {
3270                                         return ErrIntOverflowGenerated
3271                                 }
3272                                 if iNdEx >= l {
3273                                         return io.ErrUnexpectedEOF
3274                                 }
3275                                 b := dAtA[iNdEx]
3276                                 iNdEx++
3277                                 stringLen |= (uint64(b) & 0x7F) << shift
3278                                 if b < 0x80 {
3279                                         break
3280                                 }
3281                         }
3282                         intStringLen := int(stringLen)
3283                         if intStringLen < 0 {
3284                                 return ErrInvalidLengthGenerated
3285                         }
3286                         postIndex := iNdEx + intStringLen
3287                         if postIndex > l {
3288                                 return io.ErrUnexpectedEOF
3289                         }
3290                         m.Version = string(dAtA[iNdEx:postIndex])
3291                         iNdEx = postIndex
3292                 default:
3293                         iNdEx = preIndex
3294                         skippy, err := skipGenerated(dAtA[iNdEx:])
3295                         if err != nil {
3296                                 return err
3297                         }
3298                         if skippy < 0 {
3299                                 return ErrInvalidLengthGenerated
3300                         }
3301                         if (iNdEx + skippy) > l {
3302                                 return io.ErrUnexpectedEOF
3303                         }
3304                         iNdEx += skippy
3305                 }
3306         }
3307
3308         if iNdEx > l {
3309                 return io.ErrUnexpectedEOF
3310         }
3311         return nil
3312 }
3313 func (m *APIResourceList) Unmarshal(dAtA []byte) error {
3314         l := len(dAtA)
3315         iNdEx := 0
3316         for iNdEx < l {
3317                 preIndex := iNdEx
3318                 var wire uint64
3319                 for shift := uint(0); ; shift += 7 {
3320                         if shift >= 64 {
3321                                 return ErrIntOverflowGenerated
3322                         }
3323                         if iNdEx >= l {
3324                                 return io.ErrUnexpectedEOF
3325                         }
3326                         b := dAtA[iNdEx]
3327                         iNdEx++
3328                         wire |= (uint64(b) & 0x7F) << shift
3329                         if b < 0x80 {
3330                                 break
3331                         }
3332                 }
3333                 fieldNum := int32(wire >> 3)
3334                 wireType := int(wire & 0x7)
3335                 if wireType == 4 {
3336                         return fmt.Errorf("proto: APIResourceList: wiretype end group for non-group")
3337                 }
3338                 if fieldNum <= 0 {
3339                         return fmt.Errorf("proto: APIResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
3340                 }
3341                 switch fieldNum {
3342                 case 1:
3343                         if wireType != 2 {
3344                                 return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
3345                         }
3346                         var stringLen uint64
3347                         for shift := uint(0); ; shift += 7 {
3348                                 if shift >= 64 {
3349                                         return ErrIntOverflowGenerated
3350                                 }
3351                                 if iNdEx >= l {
3352                                         return io.ErrUnexpectedEOF
3353                                 }
3354                                 b := dAtA[iNdEx]
3355                                 iNdEx++
3356                                 stringLen |= (uint64(b) & 0x7F) << shift
3357                                 if b < 0x80 {
3358                                         break
3359                                 }
3360                         }
3361                         intStringLen := int(stringLen)
3362                         if intStringLen < 0 {
3363                                 return ErrInvalidLengthGenerated
3364                         }
3365                         postIndex := iNdEx + intStringLen
3366                         if postIndex > l {
3367                                 return io.ErrUnexpectedEOF
3368                         }
3369                         m.GroupVersion = string(dAtA[iNdEx:postIndex])
3370                         iNdEx = postIndex
3371                 case 2:
3372                         if wireType != 2 {
3373                                 return fmt.Errorf("proto: wrong wireType = %d for field APIResources", wireType)
3374                         }
3375                         var msglen int
3376                         for shift := uint(0); ; shift += 7 {
3377                                 if shift >= 64 {
3378                                         return ErrIntOverflowGenerated
3379                                 }
3380                                 if iNdEx >= l {
3381                                         return io.ErrUnexpectedEOF
3382                                 }
3383                                 b := dAtA[iNdEx]
3384                                 iNdEx++
3385                                 msglen |= (int(b) & 0x7F) << shift
3386                                 if b < 0x80 {
3387                                         break
3388                                 }
3389                         }
3390                         if msglen < 0 {
3391                                 return ErrInvalidLengthGenerated
3392                         }
3393                         postIndex := iNdEx + msglen
3394                         if postIndex > l {
3395                                 return io.ErrUnexpectedEOF
3396                         }
3397                         m.APIResources = append(m.APIResources, APIResource{})
3398                         if err := m.APIResources[len(m.APIResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3399                                 return err
3400                         }
3401                         iNdEx = postIndex
3402                 default:
3403                         iNdEx = preIndex
3404                         skippy, err := skipGenerated(dAtA[iNdEx:])
3405                         if err != nil {
3406                                 return err
3407                         }
3408                         if skippy < 0 {
3409                                 return ErrInvalidLengthGenerated
3410                         }
3411                         if (iNdEx + skippy) > l {
3412                                 return io.ErrUnexpectedEOF
3413                         }
3414                         iNdEx += skippy
3415                 }
3416         }
3417
3418         if iNdEx > l {
3419                 return io.ErrUnexpectedEOF
3420         }
3421         return nil
3422 }
3423 func (m *APIVersions) Unmarshal(dAtA []byte) error {
3424         l := len(dAtA)
3425         iNdEx := 0
3426         for iNdEx < l {
3427                 preIndex := iNdEx
3428                 var wire uint64
3429                 for shift := uint(0); ; shift += 7 {
3430                         if shift >= 64 {
3431                                 return ErrIntOverflowGenerated
3432                         }
3433                         if iNdEx >= l {
3434                                 return io.ErrUnexpectedEOF
3435                         }
3436                         b := dAtA[iNdEx]
3437                         iNdEx++
3438                         wire |= (uint64(b) & 0x7F) << shift
3439                         if b < 0x80 {
3440                                 break
3441                         }
3442                 }
3443                 fieldNum := int32(wire >> 3)
3444                 wireType := int(wire & 0x7)
3445                 if wireType == 4 {
3446                         return fmt.Errorf("proto: APIVersions: wiretype end group for non-group")
3447                 }
3448                 if fieldNum <= 0 {
3449                         return fmt.Errorf("proto: APIVersions: illegal tag %d (wire type %d)", fieldNum, wire)
3450                 }
3451                 switch fieldNum {
3452                 case 1:
3453                         if wireType != 2 {
3454                                 return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
3455                         }
3456                         var stringLen uint64
3457                         for shift := uint(0); ; shift += 7 {
3458                                 if shift >= 64 {
3459                                         return ErrIntOverflowGenerated
3460                                 }
3461                                 if iNdEx >= l {
3462                                         return io.ErrUnexpectedEOF
3463                                 }
3464                                 b := dAtA[iNdEx]
3465                                 iNdEx++
3466                                 stringLen |= (uint64(b) & 0x7F) << shift
3467                                 if b < 0x80 {
3468                                         break
3469                                 }
3470                         }
3471                         intStringLen := int(stringLen)
3472                         if intStringLen < 0 {
3473                                 return ErrInvalidLengthGenerated
3474                         }
3475                         postIndex := iNdEx + intStringLen
3476                         if postIndex > l {
3477                                 return io.ErrUnexpectedEOF
3478                         }
3479                         m.Versions = append(m.Versions, string(dAtA[iNdEx:postIndex]))
3480                         iNdEx = postIndex
3481                 case 2:
3482                         if wireType != 2 {
3483                                 return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
3484                         }
3485                         var msglen int
3486                         for shift := uint(0); ; shift += 7 {
3487                                 if shift >= 64 {
3488                                         return ErrIntOverflowGenerated
3489                                 }
3490                                 if iNdEx >= l {
3491                                         return io.ErrUnexpectedEOF
3492                                 }
3493                                 b := dAtA[iNdEx]
3494                                 iNdEx++
3495                                 msglen |= (int(b) & 0x7F) << shift
3496                                 if b < 0x80 {
3497                                         break
3498                                 }
3499                         }
3500                         if msglen < 0 {
3501                                 return ErrInvalidLengthGenerated
3502                         }
3503                         postIndex := iNdEx + msglen
3504                         if postIndex > l {
3505                                 return io.ErrUnexpectedEOF
3506                         }
3507                         m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
3508                         if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3509                                 return err
3510                         }
3511                         iNdEx = postIndex
3512                 default:
3513                         iNdEx = preIndex
3514                         skippy, err := skipGenerated(dAtA[iNdEx:])
3515                         if err != nil {
3516                                 return err
3517                         }
3518                         if skippy < 0 {
3519                                 return ErrInvalidLengthGenerated
3520                         }
3521                         if (iNdEx + skippy) > l {
3522                                 return io.ErrUnexpectedEOF
3523                         }
3524                         iNdEx += skippy
3525                 }
3526         }
3527
3528         if iNdEx > l {
3529                 return io.ErrUnexpectedEOF
3530         }
3531         return nil
3532 }
3533 func (m *CreateOptions) Unmarshal(dAtA []byte) error {
3534         l := len(dAtA)
3535         iNdEx := 0
3536         for iNdEx < l {
3537                 preIndex := iNdEx
3538                 var wire uint64
3539                 for shift := uint(0); ; shift += 7 {
3540                         if shift >= 64 {
3541                                 return ErrIntOverflowGenerated
3542                         }
3543                         if iNdEx >= l {
3544                                 return io.ErrUnexpectedEOF
3545                         }
3546                         b := dAtA[iNdEx]
3547                         iNdEx++
3548                         wire |= (uint64(b) & 0x7F) << shift
3549                         if b < 0x80 {
3550                                 break
3551                         }
3552                 }
3553                 fieldNum := int32(wire >> 3)
3554                 wireType := int(wire & 0x7)
3555                 if wireType == 4 {
3556                         return fmt.Errorf("proto: CreateOptions: wiretype end group for non-group")
3557                 }
3558                 if fieldNum <= 0 {
3559                         return fmt.Errorf("proto: CreateOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3560                 }
3561                 switch fieldNum {
3562                 case 1:
3563                         if wireType != 2 {
3564                                 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
3565                         }
3566                         var stringLen uint64
3567                         for shift := uint(0); ; shift += 7 {
3568                                 if shift >= 64 {
3569                                         return ErrIntOverflowGenerated
3570                                 }
3571                                 if iNdEx >= l {
3572                                         return io.ErrUnexpectedEOF
3573                                 }
3574                                 b := dAtA[iNdEx]
3575                                 iNdEx++
3576                                 stringLen |= (uint64(b) & 0x7F) << shift
3577                                 if b < 0x80 {
3578                                         break
3579                                 }
3580                         }
3581                         intStringLen := int(stringLen)
3582                         if intStringLen < 0 {
3583                                 return ErrInvalidLengthGenerated
3584                         }
3585                         postIndex := iNdEx + intStringLen
3586                         if postIndex > l {
3587                                 return io.ErrUnexpectedEOF
3588                         }
3589                         m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
3590                         iNdEx = postIndex
3591                 case 2:
3592                         if wireType != 0 {
3593                                 return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", wireType)
3594                         }
3595                         var v int
3596                         for shift := uint(0); ; shift += 7 {
3597                                 if shift >= 64 {
3598                                         return ErrIntOverflowGenerated
3599                                 }
3600                                 if iNdEx >= l {
3601                                         return io.ErrUnexpectedEOF
3602                                 }
3603                                 b := dAtA[iNdEx]
3604                                 iNdEx++
3605                                 v |= (int(b) & 0x7F) << shift
3606                                 if b < 0x80 {
3607                                         break
3608                                 }
3609                         }
3610                         m.IncludeUninitialized = bool(v != 0)
3611                 default:
3612                         iNdEx = preIndex
3613                         skippy, err := skipGenerated(dAtA[iNdEx:])
3614                         if err != nil {
3615                                 return err
3616                         }
3617                         if skippy < 0 {
3618                                 return ErrInvalidLengthGenerated
3619                         }
3620                         if (iNdEx + skippy) > l {
3621                                 return io.ErrUnexpectedEOF
3622                         }
3623                         iNdEx += skippy
3624                 }
3625         }
3626
3627         if iNdEx > l {
3628                 return io.ErrUnexpectedEOF
3629         }
3630         return nil
3631 }
3632 func (m *DeleteOptions) Unmarshal(dAtA []byte) error {
3633         l := len(dAtA)
3634         iNdEx := 0
3635         for iNdEx < l {
3636                 preIndex := iNdEx
3637                 var wire uint64
3638                 for shift := uint(0); ; shift += 7 {
3639                         if shift >= 64 {
3640                                 return ErrIntOverflowGenerated
3641                         }
3642                         if iNdEx >= l {
3643                                 return io.ErrUnexpectedEOF
3644                         }
3645                         b := dAtA[iNdEx]
3646                         iNdEx++
3647                         wire |= (uint64(b) & 0x7F) << shift
3648                         if b < 0x80 {
3649                                 break
3650                         }
3651                 }
3652                 fieldNum := int32(wire >> 3)
3653                 wireType := int(wire & 0x7)
3654                 if wireType == 4 {
3655                         return fmt.Errorf("proto: DeleteOptions: wiretype end group for non-group")
3656                 }
3657                 if fieldNum <= 0 {
3658                         return fmt.Errorf("proto: DeleteOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3659                 }
3660                 switch fieldNum {
3661                 case 1:
3662                         if wireType != 0 {
3663                                 return fmt.Errorf("proto: wrong wireType = %d for field GracePeriodSeconds", wireType)
3664                         }
3665                         var v int64
3666                         for shift := uint(0); ; shift += 7 {
3667                                 if shift >= 64 {
3668                                         return ErrIntOverflowGenerated
3669                                 }
3670                                 if iNdEx >= l {
3671                                         return io.ErrUnexpectedEOF
3672                                 }
3673                                 b := dAtA[iNdEx]
3674                                 iNdEx++
3675                                 v |= (int64(b) & 0x7F) << shift
3676                                 if b < 0x80 {
3677                                         break
3678                                 }
3679                         }
3680                         m.GracePeriodSeconds = &v
3681                 case 2:
3682                         if wireType != 2 {
3683                                 return fmt.Errorf("proto: wrong wireType = %d for field Preconditions", wireType)
3684                         }
3685                         var msglen int
3686                         for shift := uint(0); ; shift += 7 {
3687                                 if shift >= 64 {
3688                                         return ErrIntOverflowGenerated
3689                                 }
3690                                 if iNdEx >= l {
3691                                         return io.ErrUnexpectedEOF
3692                                 }
3693                                 b := dAtA[iNdEx]
3694                                 iNdEx++
3695                                 msglen |= (int(b) & 0x7F) << shift
3696                                 if b < 0x80 {
3697                                         break
3698                                 }
3699                         }
3700                         if msglen < 0 {
3701                                 return ErrInvalidLengthGenerated
3702                         }
3703                         postIndex := iNdEx + msglen
3704                         if postIndex > l {
3705                                 return io.ErrUnexpectedEOF
3706                         }
3707                         if m.Preconditions == nil {
3708                                 m.Preconditions = &Preconditions{}
3709                         }
3710                         if err := m.Preconditions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3711                                 return err
3712                         }
3713                         iNdEx = postIndex
3714                 case 3:
3715                         if wireType != 0 {
3716                                 return fmt.Errorf("proto: wrong wireType = %d for field OrphanDependents", wireType)
3717                         }
3718                         var v int
3719                         for shift := uint(0); ; shift += 7 {
3720                                 if shift >= 64 {
3721                                         return ErrIntOverflowGenerated
3722                                 }
3723                                 if iNdEx >= l {
3724                                         return io.ErrUnexpectedEOF
3725                                 }
3726                                 b := dAtA[iNdEx]
3727                                 iNdEx++
3728                                 v |= (int(b) & 0x7F) << shift
3729                                 if b < 0x80 {
3730                                         break
3731                                 }
3732                         }
3733                         b := bool(v != 0)
3734                         m.OrphanDependents = &b
3735                 case 4:
3736                         if wireType != 2 {
3737                                 return fmt.Errorf("proto: wrong wireType = %d for field PropagationPolicy", wireType)
3738                         }
3739                         var stringLen uint64
3740                         for shift := uint(0); ; shift += 7 {
3741                                 if shift >= 64 {
3742                                         return ErrIntOverflowGenerated
3743                                 }
3744                                 if iNdEx >= l {
3745                                         return io.ErrUnexpectedEOF
3746                                 }
3747                                 b := dAtA[iNdEx]
3748                                 iNdEx++
3749                                 stringLen |= (uint64(b) & 0x7F) << shift
3750                                 if b < 0x80 {
3751                                         break
3752                                 }
3753                         }
3754                         intStringLen := int(stringLen)
3755                         if intStringLen < 0 {
3756                                 return ErrInvalidLengthGenerated
3757                         }
3758                         postIndex := iNdEx + intStringLen
3759                         if postIndex > l {
3760                                 return io.ErrUnexpectedEOF
3761                         }
3762                         s := DeletionPropagation(dAtA[iNdEx:postIndex])
3763                         m.PropagationPolicy = &s
3764                         iNdEx = postIndex
3765                 case 5:
3766                         if wireType != 2 {
3767                                 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
3768                         }
3769                         var stringLen uint64
3770                         for shift := uint(0); ; shift += 7 {
3771                                 if shift >= 64 {
3772                                         return ErrIntOverflowGenerated
3773                                 }
3774                                 if iNdEx >= l {
3775                                         return io.ErrUnexpectedEOF
3776                                 }
3777                                 b := dAtA[iNdEx]
3778                                 iNdEx++
3779                                 stringLen |= (uint64(b) & 0x7F) << shift
3780                                 if b < 0x80 {
3781                                         break
3782                                 }
3783                         }
3784                         intStringLen := int(stringLen)
3785                         if intStringLen < 0 {
3786                                 return ErrInvalidLengthGenerated
3787                         }
3788                         postIndex := iNdEx + intStringLen
3789                         if postIndex > l {
3790                                 return io.ErrUnexpectedEOF
3791                         }
3792                         m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
3793                         iNdEx = postIndex
3794                 default:
3795                         iNdEx = preIndex
3796                         skippy, err := skipGenerated(dAtA[iNdEx:])
3797                         if err != nil {
3798                                 return err
3799                         }
3800                         if skippy < 0 {
3801                                 return ErrInvalidLengthGenerated
3802                         }
3803                         if (iNdEx + skippy) > l {
3804                                 return io.ErrUnexpectedEOF
3805                         }
3806                         iNdEx += skippy
3807                 }
3808         }
3809
3810         if iNdEx > l {
3811                 return io.ErrUnexpectedEOF
3812         }
3813         return nil
3814 }
3815 func (m *Duration) Unmarshal(dAtA []byte) error {
3816         l := len(dAtA)
3817         iNdEx := 0
3818         for iNdEx < l {
3819                 preIndex := iNdEx
3820                 var wire uint64
3821                 for shift := uint(0); ; shift += 7 {
3822                         if shift >= 64 {
3823                                 return ErrIntOverflowGenerated
3824                         }
3825                         if iNdEx >= l {
3826                                 return io.ErrUnexpectedEOF
3827                         }
3828                         b := dAtA[iNdEx]
3829                         iNdEx++
3830                         wire |= (uint64(b) & 0x7F) << shift
3831                         if b < 0x80 {
3832                                 break
3833                         }
3834                 }
3835                 fieldNum := int32(wire >> 3)
3836                 wireType := int(wire & 0x7)
3837                 if wireType == 4 {
3838                         return fmt.Errorf("proto: Duration: wiretype end group for non-group")
3839                 }
3840                 if fieldNum <= 0 {
3841                         return fmt.Errorf("proto: Duration: illegal tag %d (wire type %d)", fieldNum, wire)
3842                 }
3843                 switch fieldNum {
3844                 case 1:
3845                         if wireType != 0 {
3846                                 return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
3847                         }
3848                         m.Duration = 0
3849                         for shift := uint(0); ; shift += 7 {
3850                                 if shift >= 64 {
3851                                         return ErrIntOverflowGenerated
3852                                 }
3853                                 if iNdEx >= l {
3854                                         return io.ErrUnexpectedEOF
3855                                 }
3856                                 b := dAtA[iNdEx]
3857                                 iNdEx++
3858                                 m.Duration |= (time.Duration(b) & 0x7F) << shift
3859                                 if b < 0x80 {
3860                                         break
3861                                 }
3862                         }
3863                 default:
3864                         iNdEx = preIndex
3865                         skippy, err := skipGenerated(dAtA[iNdEx:])
3866                         if err != nil {
3867                                 return err
3868                         }
3869                         if skippy < 0 {
3870                                 return ErrInvalidLengthGenerated
3871                         }
3872                         if (iNdEx + skippy) > l {
3873                                 return io.ErrUnexpectedEOF
3874                         }
3875                         iNdEx += skippy
3876                 }
3877         }
3878
3879         if iNdEx > l {
3880                 return io.ErrUnexpectedEOF
3881         }
3882         return nil
3883 }
3884 func (m *ExportOptions) Unmarshal(dAtA []byte) error {
3885         l := len(dAtA)
3886         iNdEx := 0
3887         for iNdEx < l {
3888                 preIndex := iNdEx
3889                 var wire uint64
3890                 for shift := uint(0); ; shift += 7 {
3891                         if shift >= 64 {
3892                                 return ErrIntOverflowGenerated
3893                         }
3894                         if iNdEx >= l {
3895                                 return io.ErrUnexpectedEOF
3896                         }
3897                         b := dAtA[iNdEx]
3898                         iNdEx++
3899                         wire |= (uint64(b) & 0x7F) << shift
3900                         if b < 0x80 {
3901                                 break
3902                         }
3903                 }
3904                 fieldNum := int32(wire >> 3)
3905                 wireType := int(wire & 0x7)
3906                 if wireType == 4 {
3907                         return fmt.Errorf("proto: ExportOptions: wiretype end group for non-group")
3908                 }
3909                 if fieldNum <= 0 {
3910                         return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3911                 }
3912                 switch fieldNum {
3913                 case 1:
3914                         if wireType != 0 {
3915                                 return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
3916                         }
3917                         var v int
3918                         for shift := uint(0); ; shift += 7 {
3919                                 if shift >= 64 {
3920                                         return ErrIntOverflowGenerated
3921                                 }
3922                                 if iNdEx >= l {
3923                                         return io.ErrUnexpectedEOF
3924                                 }
3925                                 b := dAtA[iNdEx]
3926                                 iNdEx++
3927                                 v |= (int(b) & 0x7F) << shift
3928                                 if b < 0x80 {
3929                                         break
3930                                 }
3931                         }
3932                         m.Export = bool(v != 0)
3933                 case 2:
3934                         if wireType != 0 {
3935                                 return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
3936                         }
3937                         var v int
3938                         for shift := uint(0); ; shift += 7 {
3939                                 if shift >= 64 {
3940                                         return ErrIntOverflowGenerated
3941                                 }
3942                                 if iNdEx >= l {
3943                                         return io.ErrUnexpectedEOF
3944                                 }
3945                                 b := dAtA[iNdEx]
3946                                 iNdEx++
3947                                 v |= (int(b) & 0x7F) << shift
3948                                 if b < 0x80 {
3949                                         break
3950                                 }
3951                         }
3952                         m.Exact = bool(v != 0)
3953                 default:
3954                         iNdEx = preIndex
3955                         skippy, err := skipGenerated(dAtA[iNdEx:])
3956                         if err != nil {
3957                                 return err
3958                         }
3959                         if skippy < 0 {
3960                                 return ErrInvalidLengthGenerated
3961                         }
3962                         if (iNdEx + skippy) > l {
3963                                 return io.ErrUnexpectedEOF
3964                         }
3965                         iNdEx += skippy
3966                 }
3967         }
3968
3969         if iNdEx > l {
3970                 return io.ErrUnexpectedEOF
3971         }
3972         return nil
3973 }
3974 func (m *GetOptions) Unmarshal(dAtA []byte) error {
3975         l := len(dAtA)
3976         iNdEx := 0
3977         for iNdEx < l {
3978                 preIndex := iNdEx
3979                 var wire uint64
3980                 for shift := uint(0); ; shift += 7 {
3981                         if shift >= 64 {
3982                                 return ErrIntOverflowGenerated
3983                         }
3984                         if iNdEx >= l {
3985                                 return io.ErrUnexpectedEOF
3986                         }
3987                         b := dAtA[iNdEx]
3988                         iNdEx++
3989                         wire |= (uint64(b) & 0x7F) << shift
3990                         if b < 0x80 {
3991                                 break
3992                         }
3993                 }
3994                 fieldNum := int32(wire >> 3)
3995                 wireType := int(wire & 0x7)
3996                 if wireType == 4 {
3997                         return fmt.Errorf("proto: GetOptions: wiretype end group for non-group")
3998                 }
3999                 if fieldNum <= 0 {
4000                         return fmt.Errorf("proto: GetOptions: illegal tag %d (wire type %d)", fieldNum, wire)
4001                 }
4002                 switch fieldNum {
4003                 case 1:
4004                         if wireType != 2 {
4005                                 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
4006                         }
4007                         var stringLen uint64
4008                         for shift := uint(0); ; shift += 7 {
4009                                 if shift >= 64 {
4010                                         return ErrIntOverflowGenerated
4011                                 }
4012                                 if iNdEx >= l {
4013                                         return io.ErrUnexpectedEOF
4014                                 }
4015                                 b := dAtA[iNdEx]
4016                                 iNdEx++
4017                                 stringLen |= (uint64(b) & 0x7F) << shift
4018                                 if b < 0x80 {
4019                                         break
4020                                 }
4021                         }
4022                         intStringLen := int(stringLen)
4023                         if intStringLen < 0 {
4024                                 return ErrInvalidLengthGenerated
4025                         }
4026                         postIndex := iNdEx + intStringLen
4027                         if postIndex > l {
4028                                 return io.ErrUnexpectedEOF
4029                         }
4030                         m.ResourceVersion = string(dAtA[iNdEx:postIndex])
4031                         iNdEx = postIndex
4032                 case 2:
4033                         if wireType != 0 {
4034                                 return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", wireType)
4035                         }
4036                         var v int
4037                         for shift := uint(0); ; shift += 7 {
4038                                 if shift >= 64 {
4039                                         return ErrIntOverflowGenerated
4040                                 }
4041                                 if iNdEx >= l {
4042                                         return io.ErrUnexpectedEOF
4043                                 }
4044                                 b := dAtA[iNdEx]
4045                                 iNdEx++
4046                                 v |= (int(b) & 0x7F) << shift
4047                                 if b < 0x80 {
4048                                         break
4049                                 }
4050                         }
4051                         m.IncludeUninitialized = bool(v != 0)
4052                 default:
4053                         iNdEx = preIndex
4054                         skippy, err := skipGenerated(dAtA[iNdEx:])
4055                         if err != nil {
4056                                 return err
4057                         }
4058                         if skippy < 0 {
4059                                 return ErrInvalidLengthGenerated
4060                         }
4061                         if (iNdEx + skippy) > l {
4062                                 return io.ErrUnexpectedEOF
4063                         }
4064                         iNdEx += skippy
4065                 }
4066         }
4067
4068         if iNdEx > l {
4069                 return io.ErrUnexpectedEOF
4070         }
4071         return nil
4072 }
4073 func (m *GroupKind) Unmarshal(dAtA []byte) error {
4074         l := len(dAtA)
4075         iNdEx := 0
4076         for iNdEx < l {
4077                 preIndex := iNdEx
4078                 var wire uint64
4079                 for shift := uint(0); ; shift += 7 {
4080                         if shift >= 64 {
4081                                 return ErrIntOverflowGenerated
4082                         }
4083                         if iNdEx >= l {
4084                                 return io.ErrUnexpectedEOF
4085                         }
4086                         b := dAtA[iNdEx]
4087                         iNdEx++
4088                         wire |= (uint64(b) & 0x7F) << shift
4089                         if b < 0x80 {
4090                                 break
4091                         }
4092                 }
4093                 fieldNum := int32(wire >> 3)
4094                 wireType := int(wire & 0x7)
4095                 if wireType == 4 {
4096                         return fmt.Errorf("proto: GroupKind: wiretype end group for non-group")
4097                 }
4098                 if fieldNum <= 0 {
4099                         return fmt.Errorf("proto: GroupKind: illegal tag %d (wire type %d)", fieldNum, wire)
4100                 }
4101                 switch fieldNum {
4102                 case 1:
4103                         if wireType != 2 {
4104                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4105                         }
4106                         var stringLen uint64
4107                         for shift := uint(0); ; shift += 7 {
4108                                 if shift >= 64 {
4109                                         return ErrIntOverflowGenerated
4110                                 }
4111                                 if iNdEx >= l {
4112                                         return io.ErrUnexpectedEOF
4113                                 }
4114                                 b := dAtA[iNdEx]
4115                                 iNdEx++
4116                                 stringLen |= (uint64(b) & 0x7F) << shift
4117                                 if b < 0x80 {
4118                                         break
4119                                 }
4120                         }
4121                         intStringLen := int(stringLen)
4122                         if intStringLen < 0 {
4123                                 return ErrInvalidLengthGenerated
4124                         }
4125                         postIndex := iNdEx + intStringLen
4126                         if postIndex > l {
4127                                 return io.ErrUnexpectedEOF
4128                         }
4129                         m.Group = string(dAtA[iNdEx:postIndex])
4130                         iNdEx = postIndex
4131                 case 2:
4132                         if wireType != 2 {
4133                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
4134                         }
4135                         var stringLen uint64
4136                         for shift := uint(0); ; shift += 7 {
4137                                 if shift >= 64 {
4138                                         return ErrIntOverflowGenerated
4139                                 }
4140                                 if iNdEx >= l {
4141                                         return io.ErrUnexpectedEOF
4142                                 }
4143                                 b := dAtA[iNdEx]
4144                                 iNdEx++
4145                                 stringLen |= (uint64(b) & 0x7F) << shift
4146                                 if b < 0x80 {
4147                                         break
4148                                 }
4149                         }
4150                         intStringLen := int(stringLen)
4151                         if intStringLen < 0 {
4152                                 return ErrInvalidLengthGenerated
4153                         }
4154                         postIndex := iNdEx + intStringLen
4155                         if postIndex > l {
4156                                 return io.ErrUnexpectedEOF
4157                         }
4158                         m.Kind = string(dAtA[iNdEx:postIndex])
4159                         iNdEx = postIndex
4160                 default:
4161                         iNdEx = preIndex
4162                         skippy, err := skipGenerated(dAtA[iNdEx:])
4163                         if err != nil {
4164                                 return err
4165                         }
4166                         if skippy < 0 {
4167                                 return ErrInvalidLengthGenerated
4168                         }
4169                         if (iNdEx + skippy) > l {
4170                                 return io.ErrUnexpectedEOF
4171                         }
4172                         iNdEx += skippy
4173                 }
4174         }
4175
4176         if iNdEx > l {
4177                 return io.ErrUnexpectedEOF
4178         }
4179         return nil
4180 }
4181 func (m *GroupResource) Unmarshal(dAtA []byte) error {
4182         l := len(dAtA)
4183         iNdEx := 0
4184         for iNdEx < l {
4185                 preIndex := iNdEx
4186                 var wire uint64
4187                 for shift := uint(0); ; shift += 7 {
4188                         if shift >= 64 {
4189                                 return ErrIntOverflowGenerated
4190                         }
4191                         if iNdEx >= l {
4192                                 return io.ErrUnexpectedEOF
4193                         }
4194                         b := dAtA[iNdEx]
4195                         iNdEx++
4196                         wire |= (uint64(b) & 0x7F) << shift
4197                         if b < 0x80 {
4198                                 break
4199                         }
4200                 }
4201                 fieldNum := int32(wire >> 3)
4202                 wireType := int(wire & 0x7)
4203                 if wireType == 4 {
4204                         return fmt.Errorf("proto: GroupResource: wiretype end group for non-group")
4205                 }
4206                 if fieldNum <= 0 {
4207                         return fmt.Errorf("proto: GroupResource: illegal tag %d (wire type %d)", fieldNum, wire)
4208                 }
4209                 switch fieldNum {
4210                 case 1:
4211                         if wireType != 2 {
4212                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4213                         }
4214                         var stringLen uint64
4215                         for shift := uint(0); ; shift += 7 {
4216                                 if shift >= 64 {
4217                                         return ErrIntOverflowGenerated
4218                                 }
4219                                 if iNdEx >= l {
4220                                         return io.ErrUnexpectedEOF
4221                                 }
4222                                 b := dAtA[iNdEx]
4223                                 iNdEx++
4224                                 stringLen |= (uint64(b) & 0x7F) << shift
4225                                 if b < 0x80 {
4226                                         break
4227                                 }
4228                         }
4229                         intStringLen := int(stringLen)
4230                         if intStringLen < 0 {
4231                                 return ErrInvalidLengthGenerated
4232                         }
4233                         postIndex := iNdEx + intStringLen
4234                         if postIndex > l {
4235                                 return io.ErrUnexpectedEOF
4236                         }
4237                         m.Group = string(dAtA[iNdEx:postIndex])
4238                         iNdEx = postIndex
4239                 case 2:
4240                         if wireType != 2 {
4241                                 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
4242                         }
4243                         var stringLen uint64
4244                         for shift := uint(0); ; shift += 7 {
4245                                 if shift >= 64 {
4246                                         return ErrIntOverflowGenerated
4247                                 }
4248                                 if iNdEx >= l {
4249                                         return io.ErrUnexpectedEOF
4250                                 }
4251                                 b := dAtA[iNdEx]
4252                                 iNdEx++
4253                                 stringLen |= (uint64(b) & 0x7F) << shift
4254                                 if b < 0x80 {
4255                                         break
4256                                 }
4257                         }
4258                         intStringLen := int(stringLen)
4259                         if intStringLen < 0 {
4260                                 return ErrInvalidLengthGenerated
4261                         }
4262                         postIndex := iNdEx + intStringLen
4263                         if postIndex > l {
4264                                 return io.ErrUnexpectedEOF
4265                         }
4266                         m.Resource = string(dAtA[iNdEx:postIndex])
4267                         iNdEx = postIndex
4268                 default:
4269                         iNdEx = preIndex
4270                         skippy, err := skipGenerated(dAtA[iNdEx:])
4271                         if err != nil {
4272                                 return err
4273                         }
4274                         if skippy < 0 {
4275                                 return ErrInvalidLengthGenerated
4276                         }
4277                         if (iNdEx + skippy) > l {
4278                                 return io.ErrUnexpectedEOF
4279                         }
4280                         iNdEx += skippy
4281                 }
4282         }
4283
4284         if iNdEx > l {
4285                 return io.ErrUnexpectedEOF
4286         }
4287         return nil
4288 }
4289 func (m *GroupVersion) Unmarshal(dAtA []byte) error {
4290         l := len(dAtA)
4291         iNdEx := 0
4292         for iNdEx < l {
4293                 preIndex := iNdEx
4294                 var wire uint64
4295                 for shift := uint(0); ; shift += 7 {
4296                         if shift >= 64 {
4297                                 return ErrIntOverflowGenerated
4298                         }
4299                         if iNdEx >= l {
4300                                 return io.ErrUnexpectedEOF
4301                         }
4302                         b := dAtA[iNdEx]
4303                         iNdEx++
4304                         wire |= (uint64(b) & 0x7F) << shift
4305                         if b < 0x80 {
4306                                 break
4307                         }
4308                 }
4309                 fieldNum := int32(wire >> 3)
4310                 wireType := int(wire & 0x7)
4311                 if wireType == 4 {
4312                         return fmt.Errorf("proto: GroupVersion: wiretype end group for non-group")
4313                 }
4314                 if fieldNum <= 0 {
4315                         return fmt.Errorf("proto: GroupVersion: illegal tag %d (wire type %d)", fieldNum, wire)
4316                 }
4317                 switch fieldNum {
4318                 case 1:
4319                         if wireType != 2 {
4320                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4321                         }
4322                         var stringLen uint64
4323                         for shift := uint(0); ; shift += 7 {
4324                                 if shift >= 64 {
4325                                         return ErrIntOverflowGenerated
4326                                 }
4327                                 if iNdEx >= l {
4328                                         return io.ErrUnexpectedEOF
4329                                 }
4330                                 b := dAtA[iNdEx]
4331                                 iNdEx++
4332                                 stringLen |= (uint64(b) & 0x7F) << shift
4333                                 if b < 0x80 {
4334                                         break
4335                                 }
4336                         }
4337                         intStringLen := int(stringLen)
4338                         if intStringLen < 0 {
4339                                 return ErrInvalidLengthGenerated
4340                         }
4341                         postIndex := iNdEx + intStringLen
4342                         if postIndex > l {
4343                                 return io.ErrUnexpectedEOF
4344                         }
4345                         m.Group = string(dAtA[iNdEx:postIndex])
4346                         iNdEx = postIndex
4347                 case 2:
4348                         if wireType != 2 {
4349                                 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4350                         }
4351                         var stringLen uint64
4352                         for shift := uint(0); ; shift += 7 {
4353                                 if shift >= 64 {
4354                                         return ErrIntOverflowGenerated
4355                                 }
4356                                 if iNdEx >= l {
4357                                         return io.ErrUnexpectedEOF
4358                                 }
4359                                 b := dAtA[iNdEx]
4360                                 iNdEx++
4361                                 stringLen |= (uint64(b) & 0x7F) << shift
4362                                 if b < 0x80 {
4363                                         break
4364                                 }
4365                         }
4366                         intStringLen := int(stringLen)
4367                         if intStringLen < 0 {
4368                                 return ErrInvalidLengthGenerated
4369                         }
4370                         postIndex := iNdEx + intStringLen
4371                         if postIndex > l {
4372                                 return io.ErrUnexpectedEOF
4373                         }
4374                         m.Version = string(dAtA[iNdEx:postIndex])
4375                         iNdEx = postIndex
4376                 default:
4377                         iNdEx = preIndex
4378                         skippy, err := skipGenerated(dAtA[iNdEx:])
4379                         if err != nil {
4380                                 return err
4381                         }
4382                         if skippy < 0 {
4383                                 return ErrInvalidLengthGenerated
4384                         }
4385                         if (iNdEx + skippy) > l {
4386                                 return io.ErrUnexpectedEOF
4387                         }
4388                         iNdEx += skippy
4389                 }
4390         }
4391
4392         if iNdEx > l {
4393                 return io.ErrUnexpectedEOF
4394         }
4395         return nil
4396 }
4397 func (m *GroupVersionForDiscovery) Unmarshal(dAtA []byte) error {
4398         l := len(dAtA)
4399         iNdEx := 0
4400         for iNdEx < l {
4401                 preIndex := iNdEx
4402                 var wire uint64
4403                 for shift := uint(0); ; shift += 7 {
4404                         if shift >= 64 {
4405                                 return ErrIntOverflowGenerated
4406                         }
4407                         if iNdEx >= l {
4408                                 return io.ErrUnexpectedEOF
4409                         }
4410                         b := dAtA[iNdEx]
4411                         iNdEx++
4412                         wire |= (uint64(b) & 0x7F) << shift
4413                         if b < 0x80 {
4414                                 break
4415                         }
4416                 }
4417                 fieldNum := int32(wire >> 3)
4418                 wireType := int(wire & 0x7)
4419                 if wireType == 4 {
4420                         return fmt.Errorf("proto: GroupVersionForDiscovery: wiretype end group for non-group")
4421                 }
4422                 if fieldNum <= 0 {
4423                         return fmt.Errorf("proto: GroupVersionForDiscovery: illegal tag %d (wire type %d)", fieldNum, wire)
4424                 }
4425                 switch fieldNum {
4426                 case 1:
4427                         if wireType != 2 {
4428                                 return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
4429                         }
4430                         var stringLen uint64
4431                         for shift := uint(0); ; shift += 7 {
4432                                 if shift >= 64 {
4433                                         return ErrIntOverflowGenerated
4434                                 }
4435                                 if iNdEx >= l {
4436                                         return io.ErrUnexpectedEOF
4437                                 }
4438                                 b := dAtA[iNdEx]
4439                                 iNdEx++
4440                                 stringLen |= (uint64(b) & 0x7F) << shift
4441                                 if b < 0x80 {
4442                                         break
4443                                 }
4444                         }
4445                         intStringLen := int(stringLen)
4446                         if intStringLen < 0 {
4447                                 return ErrInvalidLengthGenerated
4448                         }
4449                         postIndex := iNdEx + intStringLen
4450                         if postIndex > l {
4451                                 return io.ErrUnexpectedEOF
4452                         }
4453                         m.GroupVersion = string(dAtA[iNdEx:postIndex])
4454                         iNdEx = postIndex
4455                 case 2:
4456                         if wireType != 2 {
4457                                 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4458                         }
4459                         var stringLen uint64
4460                         for shift := uint(0); ; shift += 7 {
4461                                 if shift >= 64 {
4462                                         return ErrIntOverflowGenerated
4463                                 }
4464                                 if iNdEx >= l {
4465                                         return io.ErrUnexpectedEOF
4466                                 }
4467                                 b := dAtA[iNdEx]
4468                                 iNdEx++
4469                                 stringLen |= (uint64(b) & 0x7F) << shift
4470                                 if b < 0x80 {
4471                                         break
4472                                 }
4473                         }
4474                         intStringLen := int(stringLen)
4475                         if intStringLen < 0 {
4476                                 return ErrInvalidLengthGenerated
4477                         }
4478                         postIndex := iNdEx + intStringLen
4479                         if postIndex > l {
4480                                 return io.ErrUnexpectedEOF
4481                         }
4482                         m.Version = string(dAtA[iNdEx:postIndex])
4483                         iNdEx = postIndex
4484                 default:
4485                         iNdEx = preIndex
4486                         skippy, err := skipGenerated(dAtA[iNdEx:])
4487                         if err != nil {
4488                                 return err
4489                         }
4490                         if skippy < 0 {
4491                                 return ErrInvalidLengthGenerated
4492                         }
4493                         if (iNdEx + skippy) > l {
4494                                 return io.ErrUnexpectedEOF
4495                         }
4496                         iNdEx += skippy
4497                 }
4498         }
4499
4500         if iNdEx > l {
4501                 return io.ErrUnexpectedEOF
4502         }
4503         return nil
4504 }
4505 func (m *GroupVersionKind) Unmarshal(dAtA []byte) error {
4506         l := len(dAtA)
4507         iNdEx := 0
4508         for iNdEx < l {
4509                 preIndex := iNdEx
4510                 var wire uint64
4511                 for shift := uint(0); ; shift += 7 {
4512                         if shift >= 64 {
4513                                 return ErrIntOverflowGenerated
4514                         }
4515                         if iNdEx >= l {
4516                                 return io.ErrUnexpectedEOF
4517                         }
4518                         b := dAtA[iNdEx]
4519                         iNdEx++
4520                         wire |= (uint64(b) & 0x7F) << shift
4521                         if b < 0x80 {
4522                                 break
4523                         }
4524                 }
4525                 fieldNum := int32(wire >> 3)
4526                 wireType := int(wire & 0x7)
4527                 if wireType == 4 {
4528                         return fmt.Errorf("proto: GroupVersionKind: wiretype end group for non-group")
4529                 }
4530                 if fieldNum <= 0 {
4531                         return fmt.Errorf("proto: GroupVersionKind: illegal tag %d (wire type %d)", fieldNum, wire)
4532                 }
4533                 switch fieldNum {
4534                 case 1:
4535                         if wireType != 2 {
4536                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4537                         }
4538                         var stringLen uint64
4539                         for shift := uint(0); ; shift += 7 {
4540                                 if shift >= 64 {
4541                                         return ErrIntOverflowGenerated
4542                                 }
4543                                 if iNdEx >= l {
4544                                         return io.ErrUnexpectedEOF
4545                                 }
4546                                 b := dAtA[iNdEx]
4547                                 iNdEx++
4548                                 stringLen |= (uint64(b) & 0x7F) << shift
4549                                 if b < 0x80 {
4550                                         break
4551                                 }
4552                         }
4553                         intStringLen := int(stringLen)
4554                         if intStringLen < 0 {
4555                                 return ErrInvalidLengthGenerated
4556                         }
4557                         postIndex := iNdEx + intStringLen
4558                         if postIndex > l {
4559                                 return io.ErrUnexpectedEOF
4560                         }
4561                         m.Group = string(dAtA[iNdEx:postIndex])
4562                         iNdEx = postIndex
4563                 case 2:
4564                         if wireType != 2 {
4565                                 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4566                         }
4567                         var stringLen uint64
4568                         for shift := uint(0); ; shift += 7 {
4569                                 if shift >= 64 {
4570                                         return ErrIntOverflowGenerated
4571                                 }
4572                                 if iNdEx >= l {
4573                                         return io.ErrUnexpectedEOF
4574                                 }
4575                                 b := dAtA[iNdEx]
4576                                 iNdEx++
4577                                 stringLen |= (uint64(b) & 0x7F) << shift
4578                                 if b < 0x80 {
4579                                         break
4580                                 }
4581                         }
4582                         intStringLen := int(stringLen)
4583                         if intStringLen < 0 {
4584                                 return ErrInvalidLengthGenerated
4585                         }
4586                         postIndex := iNdEx + intStringLen
4587                         if postIndex > l {
4588                                 return io.ErrUnexpectedEOF
4589                         }
4590                         m.Version = string(dAtA[iNdEx:postIndex])
4591                         iNdEx = postIndex
4592                 case 3:
4593                         if wireType != 2 {
4594                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
4595                         }
4596                         var stringLen uint64
4597                         for shift := uint(0); ; shift += 7 {
4598                                 if shift >= 64 {
4599                                         return ErrIntOverflowGenerated
4600                                 }
4601                                 if iNdEx >= l {
4602                                         return io.ErrUnexpectedEOF
4603                                 }
4604                                 b := dAtA[iNdEx]
4605                                 iNdEx++
4606                                 stringLen |= (uint64(b) & 0x7F) << shift
4607                                 if b < 0x80 {
4608                                         break
4609                                 }
4610                         }
4611                         intStringLen := int(stringLen)
4612                         if intStringLen < 0 {
4613                                 return ErrInvalidLengthGenerated
4614                         }
4615                         postIndex := iNdEx + intStringLen
4616                         if postIndex > l {
4617                                 return io.ErrUnexpectedEOF
4618                         }
4619                         m.Kind = string(dAtA[iNdEx:postIndex])
4620                         iNdEx = postIndex
4621                 default:
4622                         iNdEx = preIndex
4623                         skippy, err := skipGenerated(dAtA[iNdEx:])
4624                         if err != nil {
4625                                 return err
4626                         }
4627                         if skippy < 0 {
4628                                 return ErrInvalidLengthGenerated
4629                         }
4630                         if (iNdEx + skippy) > l {
4631                                 return io.ErrUnexpectedEOF
4632                         }
4633                         iNdEx += skippy
4634                 }
4635         }
4636
4637         if iNdEx > l {
4638                 return io.ErrUnexpectedEOF
4639         }
4640         return nil
4641 }
4642 func (m *GroupVersionResource) Unmarshal(dAtA []byte) error {
4643         l := len(dAtA)
4644         iNdEx := 0
4645         for iNdEx < l {
4646                 preIndex := iNdEx
4647                 var wire uint64
4648                 for shift := uint(0); ; shift += 7 {
4649                         if shift >= 64 {
4650                                 return ErrIntOverflowGenerated
4651                         }
4652                         if iNdEx >= l {
4653                                 return io.ErrUnexpectedEOF
4654                         }
4655                         b := dAtA[iNdEx]
4656                         iNdEx++
4657                         wire |= (uint64(b) & 0x7F) << shift
4658                         if b < 0x80 {
4659                                 break
4660                         }
4661                 }
4662                 fieldNum := int32(wire >> 3)
4663                 wireType := int(wire & 0x7)
4664                 if wireType == 4 {
4665                         return fmt.Errorf("proto: GroupVersionResource: wiretype end group for non-group")
4666                 }
4667                 if fieldNum <= 0 {
4668                         return fmt.Errorf("proto: GroupVersionResource: illegal tag %d (wire type %d)", fieldNum, wire)
4669                 }
4670                 switch fieldNum {
4671                 case 1:
4672                         if wireType != 2 {
4673                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4674                         }
4675                         var stringLen uint64
4676                         for shift := uint(0); ; shift += 7 {
4677                                 if shift >= 64 {
4678                                         return ErrIntOverflowGenerated
4679                                 }
4680                                 if iNdEx >= l {
4681                                         return io.ErrUnexpectedEOF
4682                                 }
4683                                 b := dAtA[iNdEx]
4684                                 iNdEx++
4685                                 stringLen |= (uint64(b) & 0x7F) << shift
4686                                 if b < 0x80 {
4687                                         break
4688                                 }
4689                         }
4690                         intStringLen := int(stringLen)
4691                         if intStringLen < 0 {
4692                                 return ErrInvalidLengthGenerated
4693                         }
4694                         postIndex := iNdEx + intStringLen
4695                         if postIndex > l {
4696                                 return io.ErrUnexpectedEOF
4697                         }
4698                         m.Group = string(dAtA[iNdEx:postIndex])
4699                         iNdEx = postIndex
4700                 case 2:
4701                         if wireType != 2 {
4702                                 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4703                         }
4704                         var stringLen uint64
4705                         for shift := uint(0); ; shift += 7 {
4706                                 if shift >= 64 {
4707                                         return ErrIntOverflowGenerated
4708                                 }
4709                                 if iNdEx >= l {
4710                                         return io.ErrUnexpectedEOF
4711                                 }
4712                                 b := dAtA[iNdEx]
4713                                 iNdEx++
4714                                 stringLen |= (uint64(b) & 0x7F) << shift
4715                                 if b < 0x80 {
4716                                         break
4717                                 }
4718                         }
4719                         intStringLen := int(stringLen)
4720                         if intStringLen < 0 {
4721                                 return ErrInvalidLengthGenerated
4722                         }
4723                         postIndex := iNdEx + intStringLen
4724                         if postIndex > l {
4725                                 return io.ErrUnexpectedEOF
4726                         }
4727                         m.Version = string(dAtA[iNdEx:postIndex])
4728                         iNdEx = postIndex
4729                 case 3:
4730                         if wireType != 2 {
4731                                 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
4732                         }
4733                         var stringLen uint64
4734                         for shift := uint(0); ; shift += 7 {
4735                                 if shift >= 64 {
4736                                         return ErrIntOverflowGenerated
4737                                 }
4738                                 if iNdEx >= l {
4739                                         return io.ErrUnexpectedEOF
4740                                 }
4741                                 b := dAtA[iNdEx]
4742                                 iNdEx++
4743                                 stringLen |= (uint64(b) & 0x7F) << shift
4744                                 if b < 0x80 {
4745                                         break
4746                                 }
4747                         }
4748                         intStringLen := int(stringLen)
4749                         if intStringLen < 0 {
4750                                 return ErrInvalidLengthGenerated
4751                         }
4752                         postIndex := iNdEx + intStringLen
4753                         if postIndex > l {
4754                                 return io.ErrUnexpectedEOF
4755                         }
4756                         m.Resource = string(dAtA[iNdEx:postIndex])
4757                         iNdEx = postIndex
4758                 default:
4759                         iNdEx = preIndex
4760                         skippy, err := skipGenerated(dAtA[iNdEx:])
4761                         if err != nil {
4762                                 return err
4763                         }
4764                         if skippy < 0 {
4765                                 return ErrInvalidLengthGenerated
4766                         }
4767                         if (iNdEx + skippy) > l {
4768                                 return io.ErrUnexpectedEOF
4769                         }
4770                         iNdEx += skippy
4771                 }
4772         }
4773
4774         if iNdEx > l {
4775                 return io.ErrUnexpectedEOF
4776         }
4777         return nil
4778 }
4779 func (m *Initializer) Unmarshal(dAtA []byte) error {
4780         l := len(dAtA)
4781         iNdEx := 0
4782         for iNdEx < l {
4783                 preIndex := iNdEx
4784                 var wire uint64
4785                 for shift := uint(0); ; shift += 7 {
4786                         if shift >= 64 {
4787                                 return ErrIntOverflowGenerated
4788                         }
4789                         if iNdEx >= l {
4790                                 return io.ErrUnexpectedEOF
4791                         }
4792                         b := dAtA[iNdEx]
4793                         iNdEx++
4794                         wire |= (uint64(b) & 0x7F) << shift
4795                         if b < 0x80 {
4796                                 break
4797                         }
4798                 }
4799                 fieldNum := int32(wire >> 3)
4800                 wireType := int(wire & 0x7)
4801                 if wireType == 4 {
4802                         return fmt.Errorf("proto: Initializer: wiretype end group for non-group")
4803                 }
4804                 if fieldNum <= 0 {
4805                         return fmt.Errorf("proto: Initializer: illegal tag %d (wire type %d)", fieldNum, wire)
4806                 }
4807                 switch fieldNum {
4808                 case 1:
4809                         if wireType != 2 {
4810                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4811                         }
4812                         var stringLen uint64
4813                         for shift := uint(0); ; shift += 7 {
4814                                 if shift >= 64 {
4815                                         return ErrIntOverflowGenerated
4816                                 }
4817                                 if iNdEx >= l {
4818                                         return io.ErrUnexpectedEOF
4819                                 }
4820                                 b := dAtA[iNdEx]
4821                                 iNdEx++
4822                                 stringLen |= (uint64(b) & 0x7F) << shift
4823                                 if b < 0x80 {
4824                                         break
4825                                 }
4826                         }
4827                         intStringLen := int(stringLen)
4828                         if intStringLen < 0 {
4829                                 return ErrInvalidLengthGenerated
4830                         }
4831                         postIndex := iNdEx + intStringLen
4832                         if postIndex > l {
4833                                 return io.ErrUnexpectedEOF
4834                         }
4835                         m.Name = string(dAtA[iNdEx:postIndex])
4836                         iNdEx = postIndex
4837                 default:
4838                         iNdEx = preIndex
4839                         skippy, err := skipGenerated(dAtA[iNdEx:])
4840                         if err != nil {
4841                                 return err
4842                         }
4843                         if skippy < 0 {
4844                                 return ErrInvalidLengthGenerated
4845                         }
4846                         if (iNdEx + skippy) > l {
4847                                 return io.ErrUnexpectedEOF
4848                         }
4849                         iNdEx += skippy
4850                 }
4851         }
4852
4853         if iNdEx > l {
4854                 return io.ErrUnexpectedEOF
4855         }
4856         return nil
4857 }
4858 func (m *Initializers) Unmarshal(dAtA []byte) error {
4859         l := len(dAtA)
4860         iNdEx := 0
4861         for iNdEx < l {
4862                 preIndex := iNdEx
4863                 var wire uint64
4864                 for shift := uint(0); ; shift += 7 {
4865                         if shift >= 64 {
4866                                 return ErrIntOverflowGenerated
4867                         }
4868                         if iNdEx >= l {
4869                                 return io.ErrUnexpectedEOF
4870                         }
4871                         b := dAtA[iNdEx]
4872                         iNdEx++
4873                         wire |= (uint64(b) & 0x7F) << shift
4874                         if b < 0x80 {
4875                                 break
4876                         }
4877                 }
4878                 fieldNum := int32(wire >> 3)
4879                 wireType := int(wire & 0x7)
4880                 if wireType == 4 {
4881                         return fmt.Errorf("proto: Initializers: wiretype end group for non-group")
4882                 }
4883                 if fieldNum <= 0 {
4884                         return fmt.Errorf("proto: Initializers: illegal tag %d (wire type %d)", fieldNum, wire)
4885                 }
4886                 switch fieldNum {
4887                 case 1:
4888                         if wireType != 2 {
4889                                 return fmt.Errorf("proto: wrong wireType = %d for field Pending", wireType)
4890                         }
4891                         var msglen int
4892                         for shift := uint(0); ; shift += 7 {
4893                                 if shift >= 64 {
4894                                         return ErrIntOverflowGenerated
4895                                 }
4896                                 if iNdEx >= l {
4897                                         return io.ErrUnexpectedEOF
4898                                 }
4899                                 b := dAtA[iNdEx]
4900                                 iNdEx++
4901                                 msglen |= (int(b) & 0x7F) << shift
4902                                 if b < 0x80 {
4903                                         break
4904                                 }
4905                         }
4906                         if msglen < 0 {
4907                                 return ErrInvalidLengthGenerated
4908                         }
4909                         postIndex := iNdEx + msglen
4910                         if postIndex > l {
4911                                 return io.ErrUnexpectedEOF
4912                         }
4913                         m.Pending = append(m.Pending, Initializer{})
4914                         if err := m.Pending[len(m.Pending)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4915                                 return err
4916                         }
4917                         iNdEx = postIndex
4918                 case 2:
4919                         if wireType != 2 {
4920                                 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
4921                         }
4922                         var msglen int
4923                         for shift := uint(0); ; shift += 7 {
4924                                 if shift >= 64 {
4925                                         return ErrIntOverflowGenerated
4926                                 }
4927                                 if iNdEx >= l {
4928                                         return io.ErrUnexpectedEOF
4929                                 }
4930                                 b := dAtA[iNdEx]
4931                                 iNdEx++
4932                                 msglen |= (int(b) & 0x7F) << shift
4933                                 if b < 0x80 {
4934                                         break
4935                                 }
4936                         }
4937                         if msglen < 0 {
4938                                 return ErrInvalidLengthGenerated
4939                         }
4940                         postIndex := iNdEx + msglen
4941                         if postIndex > l {
4942                                 return io.ErrUnexpectedEOF
4943                         }
4944                         if m.Result == nil {
4945                                 m.Result = &Status{}
4946                         }
4947                         if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4948                                 return err
4949                         }
4950                         iNdEx = postIndex
4951                 default:
4952                         iNdEx = preIndex
4953                         skippy, err := skipGenerated(dAtA[iNdEx:])
4954                         if err != nil {
4955                                 return err
4956                         }
4957                         if skippy < 0 {
4958                                 return ErrInvalidLengthGenerated
4959                         }
4960                         if (iNdEx + skippy) > l {
4961                                 return io.ErrUnexpectedEOF
4962                         }
4963                         iNdEx += skippy
4964                 }
4965         }
4966
4967         if iNdEx > l {
4968                 return io.ErrUnexpectedEOF
4969         }
4970         return nil
4971 }
4972 func (m *LabelSelector) Unmarshal(dAtA []byte) error {
4973         l := len(dAtA)
4974         iNdEx := 0
4975         for iNdEx < l {
4976                 preIndex := iNdEx
4977                 var wire uint64
4978                 for shift := uint(0); ; shift += 7 {
4979                         if shift >= 64 {
4980                                 return ErrIntOverflowGenerated
4981                         }
4982                         if iNdEx >= l {
4983                                 return io.ErrUnexpectedEOF
4984                         }
4985                         b := dAtA[iNdEx]
4986                         iNdEx++
4987                         wire |= (uint64(b) & 0x7F) << shift
4988                         if b < 0x80 {
4989                                 break
4990                         }
4991                 }
4992                 fieldNum := int32(wire >> 3)
4993                 wireType := int(wire & 0x7)
4994                 if wireType == 4 {
4995                         return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
4996                 }
4997                 if fieldNum <= 0 {
4998                         return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
4999                 }
5000                 switch fieldNum {
5001                 case 1:
5002                         if wireType != 2 {
5003                                 return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
5004                         }
5005                         var msglen int
5006                         for shift := uint(0); ; shift += 7 {
5007                                 if shift >= 64 {
5008                                         return ErrIntOverflowGenerated
5009                                 }
5010                                 if iNdEx >= l {
5011                                         return io.ErrUnexpectedEOF
5012                                 }
5013                                 b := dAtA[iNdEx]
5014                                 iNdEx++
5015                                 msglen |= (int(b) & 0x7F) << shift
5016                                 if b < 0x80 {
5017                                         break
5018                                 }
5019                         }
5020                         if msglen < 0 {
5021                                 return ErrInvalidLengthGenerated
5022                         }
5023                         postIndex := iNdEx + msglen
5024                         if postIndex > l {
5025                                 return io.ErrUnexpectedEOF
5026                         }
5027                         if m.MatchLabels == nil {
5028                                 m.MatchLabels = make(map[string]string)
5029                         }
5030                         var mapkey string
5031                         var mapvalue string
5032                         for iNdEx < postIndex {
5033                                 entryPreIndex := iNdEx
5034                                 var wire uint64
5035                                 for shift := uint(0); ; shift += 7 {
5036                                         if shift >= 64 {
5037                                                 return ErrIntOverflowGenerated
5038                                         }
5039                                         if iNdEx >= l {
5040                                                 return io.ErrUnexpectedEOF
5041                                         }
5042                                         b := dAtA[iNdEx]
5043                                         iNdEx++
5044                                         wire |= (uint64(b) & 0x7F) << shift
5045                                         if b < 0x80 {
5046                                                 break
5047                                         }
5048                                 }
5049                                 fieldNum := int32(wire >> 3)
5050                                 if fieldNum == 1 {
5051                                         var stringLenmapkey uint64
5052                                         for shift := uint(0); ; shift += 7 {
5053                                                 if shift >= 64 {
5054                                                         return ErrIntOverflowGenerated
5055                                                 }
5056                                                 if iNdEx >= l {
5057                                                         return io.ErrUnexpectedEOF
5058                                                 }
5059                                                 b := dAtA[iNdEx]
5060                                                 iNdEx++
5061                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
5062                                                 if b < 0x80 {
5063                                                         break
5064                                                 }
5065                                         }
5066                                         intStringLenmapkey := int(stringLenmapkey)
5067                                         if intStringLenmapkey < 0 {
5068                                                 return ErrInvalidLengthGenerated
5069                                         }
5070                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
5071                                         if postStringIndexmapkey > l {
5072                                                 return io.ErrUnexpectedEOF
5073                                         }
5074                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5075                                         iNdEx = postStringIndexmapkey
5076                                 } else if fieldNum == 2 {
5077                                         var stringLenmapvalue uint64
5078                                         for shift := uint(0); ; shift += 7 {
5079                                                 if shift >= 64 {
5080                                                         return ErrIntOverflowGenerated
5081                                                 }
5082                                                 if iNdEx >= l {
5083                                                         return io.ErrUnexpectedEOF
5084                                                 }
5085                                                 b := dAtA[iNdEx]
5086                                                 iNdEx++
5087                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
5088                                                 if b < 0x80 {
5089                                                         break
5090                                                 }
5091                                         }
5092                                         intStringLenmapvalue := int(stringLenmapvalue)
5093                                         if intStringLenmapvalue < 0 {
5094                                                 return ErrInvalidLengthGenerated
5095                                         }
5096                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
5097                                         if postStringIndexmapvalue > l {
5098                                                 return io.ErrUnexpectedEOF
5099                                         }
5100                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
5101                                         iNdEx = postStringIndexmapvalue
5102                                 } else {
5103                                         iNdEx = entryPreIndex
5104                                         skippy, err := skipGenerated(dAtA[iNdEx:])
5105                                         if err != nil {
5106                                                 return err
5107                                         }
5108                                         if skippy < 0 {
5109                                                 return ErrInvalidLengthGenerated
5110                                         }
5111                                         if (iNdEx + skippy) > postIndex {
5112                                                 return io.ErrUnexpectedEOF
5113                                         }
5114                                         iNdEx += skippy
5115                                 }
5116                         }
5117                         m.MatchLabels[mapkey] = mapvalue
5118                         iNdEx = postIndex
5119                 case 2:
5120                         if wireType != 2 {
5121                                 return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
5122                         }
5123                         var msglen int
5124                         for shift := uint(0); ; shift += 7 {
5125                                 if shift >= 64 {
5126                                         return ErrIntOverflowGenerated
5127                                 }
5128                                 if iNdEx >= l {
5129                                         return io.ErrUnexpectedEOF
5130                                 }
5131                                 b := dAtA[iNdEx]
5132                                 iNdEx++
5133                                 msglen |= (int(b) & 0x7F) << shift
5134                                 if b < 0x80 {
5135                                         break
5136                                 }
5137                         }
5138                         if msglen < 0 {
5139                                 return ErrInvalidLengthGenerated
5140                         }
5141                         postIndex := iNdEx + msglen
5142                         if postIndex > l {
5143                                 return io.ErrUnexpectedEOF
5144                         }
5145                         m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
5146                         if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5147                                 return err
5148                         }
5149                         iNdEx = postIndex
5150                 default:
5151                         iNdEx = preIndex
5152                         skippy, err := skipGenerated(dAtA[iNdEx:])
5153                         if err != nil {
5154                                 return err
5155                         }
5156                         if skippy < 0 {
5157                                 return ErrInvalidLengthGenerated
5158                         }
5159                         if (iNdEx + skippy) > l {
5160                                 return io.ErrUnexpectedEOF
5161                         }
5162                         iNdEx += skippy
5163                 }
5164         }
5165
5166         if iNdEx > l {
5167                 return io.ErrUnexpectedEOF
5168         }
5169         return nil
5170 }
5171 func (m *LabelSelectorRequirement) Unmarshal(dAtA []byte) error {
5172         l := len(dAtA)
5173         iNdEx := 0
5174         for iNdEx < l {
5175                 preIndex := iNdEx
5176                 var wire uint64
5177                 for shift := uint(0); ; shift += 7 {
5178                         if shift >= 64 {
5179                                 return ErrIntOverflowGenerated
5180                         }
5181                         if iNdEx >= l {
5182                                 return io.ErrUnexpectedEOF
5183                         }
5184                         b := dAtA[iNdEx]
5185                         iNdEx++
5186                         wire |= (uint64(b) & 0x7F) << shift
5187                         if b < 0x80 {
5188                                 break
5189                         }
5190                 }
5191                 fieldNum := int32(wire >> 3)
5192                 wireType := int(wire & 0x7)
5193                 if wireType == 4 {
5194                         return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
5195                 }
5196                 if fieldNum <= 0 {
5197                         return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
5198                 }
5199                 switch fieldNum {
5200                 case 1:
5201                         if wireType != 2 {
5202                                 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
5203                         }
5204                         var stringLen uint64
5205                         for shift := uint(0); ; shift += 7 {
5206                                 if shift >= 64 {
5207                                         return ErrIntOverflowGenerated
5208                                 }
5209                                 if iNdEx >= l {
5210                                         return io.ErrUnexpectedEOF
5211                                 }
5212                                 b := dAtA[iNdEx]
5213                                 iNdEx++
5214                                 stringLen |= (uint64(b) & 0x7F) << shift
5215                                 if b < 0x80 {
5216                                         break
5217                                 }
5218                         }
5219                         intStringLen := int(stringLen)
5220                         if intStringLen < 0 {
5221                                 return ErrInvalidLengthGenerated
5222                         }
5223                         postIndex := iNdEx + intStringLen
5224                         if postIndex > l {
5225                                 return io.ErrUnexpectedEOF
5226                         }
5227                         m.Key = string(dAtA[iNdEx:postIndex])
5228                         iNdEx = postIndex
5229                 case 2:
5230                         if wireType != 2 {
5231                                 return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
5232                         }
5233                         var stringLen uint64
5234                         for shift := uint(0); ; shift += 7 {
5235                                 if shift >= 64 {
5236                                         return ErrIntOverflowGenerated
5237                                 }
5238                                 if iNdEx >= l {
5239                                         return io.ErrUnexpectedEOF
5240                                 }
5241                                 b := dAtA[iNdEx]
5242                                 iNdEx++
5243                                 stringLen |= (uint64(b) & 0x7F) << shift
5244                                 if b < 0x80 {
5245                                         break
5246                                 }
5247                         }
5248                         intStringLen := int(stringLen)
5249                         if intStringLen < 0 {
5250                                 return ErrInvalidLengthGenerated
5251                         }
5252                         postIndex := iNdEx + intStringLen
5253                         if postIndex > l {
5254                                 return io.ErrUnexpectedEOF
5255                         }
5256                         m.Operator = LabelSelectorOperator(dAtA[iNdEx:postIndex])
5257                         iNdEx = postIndex
5258                 case 3:
5259                         if wireType != 2 {
5260                                 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
5261                         }
5262                         var stringLen uint64
5263                         for shift := uint(0); ; shift += 7 {
5264                                 if shift >= 64 {
5265                                         return ErrIntOverflowGenerated
5266                                 }
5267                                 if iNdEx >= l {
5268                                         return io.ErrUnexpectedEOF
5269                                 }
5270                                 b := dAtA[iNdEx]
5271                                 iNdEx++
5272                                 stringLen |= (uint64(b) & 0x7F) << shift
5273                                 if b < 0x80 {
5274                                         break
5275                                 }
5276                         }
5277                         intStringLen := int(stringLen)
5278                         if intStringLen < 0 {
5279                                 return ErrInvalidLengthGenerated
5280                         }
5281                         postIndex := iNdEx + intStringLen
5282                         if postIndex > l {
5283                                 return io.ErrUnexpectedEOF
5284                         }
5285                         m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
5286                         iNdEx = postIndex
5287                 default:
5288                         iNdEx = preIndex
5289                         skippy, err := skipGenerated(dAtA[iNdEx:])
5290                         if err != nil {
5291                                 return err
5292                         }
5293                         if skippy < 0 {
5294                                 return ErrInvalidLengthGenerated
5295                         }
5296                         if (iNdEx + skippy) > l {
5297                                 return io.ErrUnexpectedEOF
5298                         }
5299                         iNdEx += skippy
5300                 }
5301         }
5302
5303         if iNdEx > l {
5304                 return io.ErrUnexpectedEOF
5305         }
5306         return nil
5307 }
5308 func (m *List) Unmarshal(dAtA []byte) error {
5309         l := len(dAtA)
5310         iNdEx := 0
5311         for iNdEx < l {
5312                 preIndex := iNdEx
5313                 var wire uint64
5314                 for shift := uint(0); ; shift += 7 {
5315                         if shift >= 64 {
5316                                 return ErrIntOverflowGenerated
5317                         }
5318                         if iNdEx >= l {
5319                                 return io.ErrUnexpectedEOF
5320                         }
5321                         b := dAtA[iNdEx]
5322                         iNdEx++
5323                         wire |= (uint64(b) & 0x7F) << shift
5324                         if b < 0x80 {
5325                                 break
5326                         }
5327                 }
5328                 fieldNum := int32(wire >> 3)
5329                 wireType := int(wire & 0x7)
5330                 if wireType == 4 {
5331                         return fmt.Errorf("proto: List: wiretype end group for non-group")
5332                 }
5333                 if fieldNum <= 0 {
5334                         return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
5335                 }
5336                 switch fieldNum {
5337                 case 1:
5338                         if wireType != 2 {
5339                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5340                         }
5341                         var msglen int
5342                         for shift := uint(0); ; shift += 7 {
5343                                 if shift >= 64 {
5344                                         return ErrIntOverflowGenerated
5345                                 }
5346                                 if iNdEx >= l {
5347                                         return io.ErrUnexpectedEOF
5348                                 }
5349                                 b := dAtA[iNdEx]
5350                                 iNdEx++
5351                                 msglen |= (int(b) & 0x7F) << shift
5352                                 if b < 0x80 {
5353                                         break
5354                                 }
5355                         }
5356                         if msglen < 0 {
5357                                 return ErrInvalidLengthGenerated
5358                         }
5359                         postIndex := iNdEx + msglen
5360                         if postIndex > l {
5361                                 return io.ErrUnexpectedEOF
5362                         }
5363                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5364                                 return err
5365                         }
5366                         iNdEx = postIndex
5367                 case 2:
5368                         if wireType != 2 {
5369                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5370                         }
5371                         var msglen int
5372                         for shift := uint(0); ; shift += 7 {
5373                                 if shift >= 64 {
5374                                         return ErrIntOverflowGenerated
5375                                 }
5376                                 if iNdEx >= l {
5377                                         return io.ErrUnexpectedEOF
5378                                 }
5379                                 b := dAtA[iNdEx]
5380                                 iNdEx++
5381                                 msglen |= (int(b) & 0x7F) << shift
5382                                 if b < 0x80 {
5383                                         break
5384                                 }
5385                         }
5386                         if msglen < 0 {
5387                                 return ErrInvalidLengthGenerated
5388                         }
5389                         postIndex := iNdEx + msglen
5390                         if postIndex > l {
5391                                 return io.ErrUnexpectedEOF
5392                         }
5393                         m.Items = append(m.Items, k8s_io_apimachinery_pkg_runtime.RawExtension{})
5394                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5395                                 return err
5396                         }
5397                         iNdEx = postIndex
5398                 default:
5399                         iNdEx = preIndex
5400                         skippy, err := skipGenerated(dAtA[iNdEx:])
5401                         if err != nil {
5402                                 return err
5403                         }
5404                         if skippy < 0 {
5405                                 return ErrInvalidLengthGenerated
5406                         }
5407                         if (iNdEx + skippy) > l {
5408                                 return io.ErrUnexpectedEOF
5409                         }
5410                         iNdEx += skippy
5411                 }
5412         }
5413
5414         if iNdEx > l {
5415                 return io.ErrUnexpectedEOF
5416         }
5417         return nil
5418 }
5419 func (m *ListMeta) Unmarshal(dAtA []byte) error {
5420         l := len(dAtA)
5421         iNdEx := 0
5422         for iNdEx < l {
5423                 preIndex := iNdEx
5424                 var wire uint64
5425                 for shift := uint(0); ; shift += 7 {
5426                         if shift >= 64 {
5427                                 return ErrIntOverflowGenerated
5428                         }
5429                         if iNdEx >= l {
5430                                 return io.ErrUnexpectedEOF
5431                         }
5432                         b := dAtA[iNdEx]
5433                         iNdEx++
5434                         wire |= (uint64(b) & 0x7F) << shift
5435                         if b < 0x80 {
5436                                 break
5437                         }
5438                 }
5439                 fieldNum := int32(wire >> 3)
5440                 wireType := int(wire & 0x7)
5441                 if wireType == 4 {
5442                         return fmt.Errorf("proto: ListMeta: wiretype end group for non-group")
5443                 }
5444                 if fieldNum <= 0 {
5445                         return fmt.Errorf("proto: ListMeta: illegal tag %d (wire type %d)", fieldNum, wire)
5446                 }
5447                 switch fieldNum {
5448                 case 1:
5449                         if wireType != 2 {
5450                                 return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
5451                         }
5452                         var stringLen uint64
5453                         for shift := uint(0); ; shift += 7 {
5454                                 if shift >= 64 {
5455                                         return ErrIntOverflowGenerated
5456                                 }
5457                                 if iNdEx >= l {
5458                                         return io.ErrUnexpectedEOF
5459                                 }
5460                                 b := dAtA[iNdEx]
5461                                 iNdEx++
5462                                 stringLen |= (uint64(b) & 0x7F) << shift
5463                                 if b < 0x80 {
5464                                         break
5465                                 }
5466                         }
5467                         intStringLen := int(stringLen)
5468                         if intStringLen < 0 {
5469                                 return ErrInvalidLengthGenerated
5470                         }
5471                         postIndex := iNdEx + intStringLen
5472                         if postIndex > l {
5473                                 return io.ErrUnexpectedEOF
5474                         }
5475                         m.SelfLink = string(dAtA[iNdEx:postIndex])
5476                         iNdEx = postIndex
5477                 case 2:
5478                         if wireType != 2 {
5479                                 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
5480                         }
5481                         var stringLen uint64
5482                         for shift := uint(0); ; shift += 7 {
5483                                 if shift >= 64 {
5484                                         return ErrIntOverflowGenerated
5485                                 }
5486                                 if iNdEx >= l {
5487                                         return io.ErrUnexpectedEOF
5488                                 }
5489                                 b := dAtA[iNdEx]
5490                                 iNdEx++
5491                                 stringLen |= (uint64(b) & 0x7F) << shift
5492                                 if b < 0x80 {
5493                                         break
5494                                 }
5495                         }
5496                         intStringLen := int(stringLen)
5497                         if intStringLen < 0 {
5498                                 return ErrInvalidLengthGenerated
5499                         }
5500                         postIndex := iNdEx + intStringLen
5501                         if postIndex > l {
5502                                 return io.ErrUnexpectedEOF
5503                         }
5504                         m.ResourceVersion = string(dAtA[iNdEx:postIndex])
5505                         iNdEx = postIndex
5506                 case 3:
5507                         if wireType != 2 {
5508                                 return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType)
5509                         }
5510                         var stringLen uint64
5511                         for shift := uint(0); ; shift += 7 {
5512                                 if shift >= 64 {
5513                                         return ErrIntOverflowGenerated
5514                                 }
5515                                 if iNdEx >= l {
5516                                         return io.ErrUnexpectedEOF
5517                                 }
5518                                 b := dAtA[iNdEx]
5519                                 iNdEx++
5520                                 stringLen |= (uint64(b) & 0x7F) << shift
5521                                 if b < 0x80 {
5522                                         break
5523                                 }
5524                         }
5525                         intStringLen := int(stringLen)
5526                         if intStringLen < 0 {
5527                                 return ErrInvalidLengthGenerated
5528                         }
5529                         postIndex := iNdEx + intStringLen
5530                         if postIndex > l {
5531                                 return io.ErrUnexpectedEOF
5532                         }
5533                         m.Continue = string(dAtA[iNdEx:postIndex])
5534                         iNdEx = postIndex
5535                 default:
5536                         iNdEx = preIndex
5537                         skippy, err := skipGenerated(dAtA[iNdEx:])
5538                         if err != nil {
5539                                 return err
5540                         }
5541                         if skippy < 0 {
5542                                 return ErrInvalidLengthGenerated
5543                         }
5544                         if (iNdEx + skippy) > l {
5545                                 return io.ErrUnexpectedEOF
5546                         }
5547                         iNdEx += skippy
5548                 }
5549         }
5550
5551         if iNdEx > l {
5552                 return io.ErrUnexpectedEOF
5553         }
5554         return nil
5555 }
5556 func (m *ListOptions) Unmarshal(dAtA []byte) error {
5557         l := len(dAtA)
5558         iNdEx := 0
5559         for iNdEx < l {
5560                 preIndex := iNdEx
5561                 var wire uint64
5562                 for shift := uint(0); ; shift += 7 {
5563                         if shift >= 64 {
5564                                 return ErrIntOverflowGenerated
5565                         }
5566                         if iNdEx >= l {
5567                                 return io.ErrUnexpectedEOF
5568                         }
5569                         b := dAtA[iNdEx]
5570                         iNdEx++
5571                         wire |= (uint64(b) & 0x7F) << shift
5572                         if b < 0x80 {
5573                                 break
5574                         }
5575                 }
5576                 fieldNum := int32(wire >> 3)
5577                 wireType := int(wire & 0x7)
5578                 if wireType == 4 {
5579                         return fmt.Errorf("proto: ListOptions: wiretype end group for non-group")
5580                 }
5581                 if fieldNum <= 0 {
5582                         return fmt.Errorf("proto: ListOptions: illegal tag %d (wire type %d)", fieldNum, wire)
5583                 }
5584                 switch fieldNum {
5585                 case 1:
5586                         if wireType != 2 {
5587                                 return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
5588                         }
5589                         var stringLen uint64
5590                         for shift := uint(0); ; shift += 7 {
5591                                 if shift >= 64 {
5592                                         return ErrIntOverflowGenerated
5593                                 }
5594                                 if iNdEx >= l {
5595                                         return io.ErrUnexpectedEOF
5596                                 }
5597                                 b := dAtA[iNdEx]
5598                                 iNdEx++
5599                                 stringLen |= (uint64(b) & 0x7F) << shift
5600                                 if b < 0x80 {
5601                                         break
5602                                 }
5603                         }
5604                         intStringLen := int(stringLen)
5605                         if intStringLen < 0 {
5606                                 return ErrInvalidLengthGenerated
5607                         }
5608                         postIndex := iNdEx + intStringLen
5609                         if postIndex > l {
5610                                 return io.ErrUnexpectedEOF
5611                         }
5612                         m.LabelSelector = string(dAtA[iNdEx:postIndex])
5613                         iNdEx = postIndex
5614                 case 2:
5615                         if wireType != 2 {
5616                                 return fmt.Errorf("proto: wrong wireType = %d for field FieldSelector", wireType)
5617                         }
5618                         var stringLen uint64
5619                         for shift := uint(0); ; shift += 7 {
5620                                 if shift >= 64 {
5621                                         return ErrIntOverflowGenerated
5622                                 }
5623                                 if iNdEx >= l {
5624                                         return io.ErrUnexpectedEOF
5625                                 }
5626                                 b := dAtA[iNdEx]
5627                                 iNdEx++
5628                                 stringLen |= (uint64(b) & 0x7F) << shift
5629                                 if b < 0x80 {
5630                                         break
5631                                 }
5632                         }
5633                         intStringLen := int(stringLen)
5634                         if intStringLen < 0 {
5635                                 return ErrInvalidLengthGenerated
5636                         }
5637                         postIndex := iNdEx + intStringLen
5638                         if postIndex > l {
5639                                 return io.ErrUnexpectedEOF
5640                         }
5641                         m.FieldSelector = string(dAtA[iNdEx:postIndex])
5642                         iNdEx = postIndex
5643                 case 3:
5644                         if wireType != 0 {
5645                                 return fmt.Errorf("proto: wrong wireType = %d for field Watch", wireType)
5646                         }
5647                         var v int
5648                         for shift := uint(0); ; shift += 7 {
5649                                 if shift >= 64 {
5650                                         return ErrIntOverflowGenerated
5651                                 }
5652                                 if iNdEx >= l {
5653                                         return io.ErrUnexpectedEOF
5654                                 }
5655                                 b := dAtA[iNdEx]
5656                                 iNdEx++
5657                                 v |= (int(b) & 0x7F) << shift
5658                                 if b < 0x80 {
5659                                         break
5660                                 }
5661                         }
5662                         m.Watch = bool(v != 0)
5663                 case 4:
5664                         if wireType != 2 {
5665                                 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
5666                         }
5667                         var stringLen uint64
5668                         for shift := uint(0); ; shift += 7 {
5669                                 if shift >= 64 {
5670                                         return ErrIntOverflowGenerated
5671                                 }
5672                                 if iNdEx >= l {
5673                                         return io.ErrUnexpectedEOF
5674                                 }
5675                                 b := dAtA[iNdEx]
5676                                 iNdEx++
5677                                 stringLen |= (uint64(b) & 0x7F) << shift
5678                                 if b < 0x80 {
5679                                         break
5680                                 }
5681                         }
5682                         intStringLen := int(stringLen)
5683                         if intStringLen < 0 {
5684                                 return ErrInvalidLengthGenerated
5685                         }
5686                         postIndex := iNdEx + intStringLen
5687                         if postIndex > l {
5688                                 return io.ErrUnexpectedEOF
5689                         }
5690                         m.ResourceVersion = string(dAtA[iNdEx:postIndex])
5691                         iNdEx = postIndex
5692                 case 5:
5693                         if wireType != 0 {
5694                                 return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
5695                         }
5696                         var v int64
5697                         for shift := uint(0); ; shift += 7 {
5698                                 if shift >= 64 {
5699                                         return ErrIntOverflowGenerated
5700                                 }
5701                                 if iNdEx >= l {
5702                                         return io.ErrUnexpectedEOF
5703                                 }
5704                                 b := dAtA[iNdEx]
5705                                 iNdEx++
5706                                 v |= (int64(b) & 0x7F) << shift
5707                                 if b < 0x80 {
5708                                         break
5709                                 }
5710                         }
5711                         m.TimeoutSeconds = &v
5712                 case 6:
5713                         if wireType != 0 {
5714                                 return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", wireType)
5715                         }
5716                         var v int
5717                         for shift := uint(0); ; shift += 7 {
5718                                 if shift >= 64 {
5719                                         return ErrIntOverflowGenerated
5720                                 }
5721                                 if iNdEx >= l {
5722                                         return io.ErrUnexpectedEOF
5723                                 }
5724                                 b := dAtA[iNdEx]
5725                                 iNdEx++
5726                                 v |= (int(b) & 0x7F) << shift
5727                                 if b < 0x80 {
5728                                         break
5729                                 }
5730                         }
5731                         m.IncludeUninitialized = bool(v != 0)
5732                 case 7:
5733                         if wireType != 0 {
5734                                 return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
5735                         }
5736                         m.Limit = 0
5737                         for shift := uint(0); ; shift += 7 {
5738                                 if shift >= 64 {
5739                                         return ErrIntOverflowGenerated
5740                                 }
5741                                 if iNdEx >= l {
5742                                         return io.ErrUnexpectedEOF
5743                                 }
5744                                 b := dAtA[iNdEx]
5745                                 iNdEx++
5746                                 m.Limit |= (int64(b) & 0x7F) << shift
5747                                 if b < 0x80 {
5748                                         break
5749                                 }
5750                         }
5751                 case 8:
5752                         if wireType != 2 {
5753                                 return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType)
5754                         }
5755                         var stringLen uint64
5756                         for shift := uint(0); ; shift += 7 {
5757                                 if shift >= 64 {
5758                                         return ErrIntOverflowGenerated
5759                                 }
5760                                 if iNdEx >= l {
5761                                         return io.ErrUnexpectedEOF
5762                                 }
5763                                 b := dAtA[iNdEx]
5764                                 iNdEx++
5765                                 stringLen |= (uint64(b) & 0x7F) << shift
5766                                 if b < 0x80 {
5767                                         break
5768                                 }
5769                         }
5770                         intStringLen := int(stringLen)
5771                         if intStringLen < 0 {
5772                                 return ErrInvalidLengthGenerated
5773                         }
5774                         postIndex := iNdEx + intStringLen
5775                         if postIndex > l {
5776                                 return io.ErrUnexpectedEOF
5777                         }
5778                         m.Continue = string(dAtA[iNdEx:postIndex])
5779                         iNdEx = postIndex
5780                 default:
5781                         iNdEx = preIndex
5782                         skippy, err := skipGenerated(dAtA[iNdEx:])
5783                         if err != nil {
5784                                 return err
5785                         }
5786                         if skippy < 0 {
5787                                 return ErrInvalidLengthGenerated
5788                         }
5789                         if (iNdEx + skippy) > l {
5790                                 return io.ErrUnexpectedEOF
5791                         }
5792                         iNdEx += skippy
5793                 }
5794         }
5795
5796         if iNdEx > l {
5797                 return io.ErrUnexpectedEOF
5798         }
5799         return nil
5800 }
5801 func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
5802         l := len(dAtA)
5803         iNdEx := 0
5804         for iNdEx < l {
5805                 preIndex := iNdEx
5806                 var wire uint64
5807                 for shift := uint(0); ; shift += 7 {
5808                         if shift >= 64 {
5809                                 return ErrIntOverflowGenerated
5810                         }
5811                         if iNdEx >= l {
5812                                 return io.ErrUnexpectedEOF
5813                         }
5814                         b := dAtA[iNdEx]
5815                         iNdEx++
5816                         wire |= (uint64(b) & 0x7F) << shift
5817                         if b < 0x80 {
5818                                 break
5819                         }
5820                 }
5821                 fieldNum := int32(wire >> 3)
5822                 wireType := int(wire & 0x7)
5823                 if wireType == 4 {
5824                         return fmt.Errorf("proto: ObjectMeta: wiretype end group for non-group")
5825                 }
5826                 if fieldNum <= 0 {
5827                         return fmt.Errorf("proto: ObjectMeta: illegal tag %d (wire type %d)", fieldNum, wire)
5828                 }
5829                 switch fieldNum {
5830                 case 1:
5831                         if wireType != 2 {
5832                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5833                         }
5834                         var stringLen uint64
5835                         for shift := uint(0); ; shift += 7 {
5836                                 if shift >= 64 {
5837                                         return ErrIntOverflowGenerated
5838                                 }
5839                                 if iNdEx >= l {
5840                                         return io.ErrUnexpectedEOF
5841                                 }
5842                                 b := dAtA[iNdEx]
5843                                 iNdEx++
5844                                 stringLen |= (uint64(b) & 0x7F) << shift
5845                                 if b < 0x80 {
5846                                         break
5847                                 }
5848                         }
5849                         intStringLen := int(stringLen)
5850                         if intStringLen < 0 {
5851                                 return ErrInvalidLengthGenerated
5852                         }
5853                         postIndex := iNdEx + intStringLen
5854                         if postIndex > l {
5855                                 return io.ErrUnexpectedEOF
5856                         }
5857                         m.Name = string(dAtA[iNdEx:postIndex])
5858                         iNdEx = postIndex
5859                 case 2:
5860                         if wireType != 2 {
5861                                 return fmt.Errorf("proto: wrong wireType = %d for field GenerateName", wireType)
5862                         }
5863                         var stringLen uint64
5864                         for shift := uint(0); ; shift += 7 {
5865                                 if shift >= 64 {
5866                                         return ErrIntOverflowGenerated
5867                                 }
5868                                 if iNdEx >= l {
5869                                         return io.ErrUnexpectedEOF
5870                                 }
5871                                 b := dAtA[iNdEx]
5872                                 iNdEx++
5873                                 stringLen |= (uint64(b) & 0x7F) << shift
5874                                 if b < 0x80 {
5875                                         break
5876                                 }
5877                         }
5878                         intStringLen := int(stringLen)
5879                         if intStringLen < 0 {
5880                                 return ErrInvalidLengthGenerated
5881                         }
5882                         postIndex := iNdEx + intStringLen
5883                         if postIndex > l {
5884                                 return io.ErrUnexpectedEOF
5885                         }
5886                         m.GenerateName = string(dAtA[iNdEx:postIndex])
5887                         iNdEx = postIndex
5888                 case 3:
5889                         if wireType != 2 {
5890                                 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
5891                         }
5892                         var stringLen uint64
5893                         for shift := uint(0); ; shift += 7 {
5894                                 if shift >= 64 {
5895                                         return ErrIntOverflowGenerated
5896                                 }
5897                                 if iNdEx >= l {
5898                                         return io.ErrUnexpectedEOF
5899                                 }
5900                                 b := dAtA[iNdEx]
5901                                 iNdEx++
5902                                 stringLen |= (uint64(b) & 0x7F) << shift
5903                                 if b < 0x80 {
5904                                         break
5905                                 }
5906                         }
5907                         intStringLen := int(stringLen)
5908                         if intStringLen < 0 {
5909                                 return ErrInvalidLengthGenerated
5910                         }
5911                         postIndex := iNdEx + intStringLen
5912                         if postIndex > l {
5913                                 return io.ErrUnexpectedEOF
5914                         }
5915                         m.Namespace = string(dAtA[iNdEx:postIndex])
5916                         iNdEx = postIndex
5917                 case 4:
5918                         if wireType != 2 {
5919                                 return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
5920                         }
5921                         var stringLen uint64
5922                         for shift := uint(0); ; shift += 7 {
5923                                 if shift >= 64 {
5924                                         return ErrIntOverflowGenerated
5925                                 }
5926                                 if iNdEx >= l {
5927                                         return io.ErrUnexpectedEOF
5928                                 }
5929                                 b := dAtA[iNdEx]
5930                                 iNdEx++
5931                                 stringLen |= (uint64(b) & 0x7F) << shift
5932                                 if b < 0x80 {
5933                                         break
5934                                 }
5935                         }
5936                         intStringLen := int(stringLen)
5937                         if intStringLen < 0 {
5938                                 return ErrInvalidLengthGenerated
5939                         }
5940                         postIndex := iNdEx + intStringLen
5941                         if postIndex > l {
5942                                 return io.ErrUnexpectedEOF
5943                         }
5944                         m.SelfLink = string(dAtA[iNdEx:postIndex])
5945                         iNdEx = postIndex
5946                 case 5:
5947                         if wireType != 2 {
5948                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
5949                         }
5950                         var stringLen uint64
5951                         for shift := uint(0); ; shift += 7 {
5952                                 if shift >= 64 {
5953                                         return ErrIntOverflowGenerated
5954                                 }
5955                                 if iNdEx >= l {
5956                                         return io.ErrUnexpectedEOF
5957                                 }
5958                                 b := dAtA[iNdEx]
5959                                 iNdEx++
5960                                 stringLen |= (uint64(b) & 0x7F) << shift
5961                                 if b < 0x80 {
5962                                         break
5963                                 }
5964                         }
5965                         intStringLen := int(stringLen)
5966                         if intStringLen < 0 {
5967                                 return ErrInvalidLengthGenerated
5968                         }
5969                         postIndex := iNdEx + intStringLen
5970                         if postIndex > l {
5971                                 return io.ErrUnexpectedEOF
5972                         }
5973                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
5974                         iNdEx = postIndex
5975                 case 6:
5976                         if wireType != 2 {
5977                                 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
5978                         }
5979                         var stringLen uint64
5980                         for shift := uint(0); ; shift += 7 {
5981                                 if shift >= 64 {
5982                                         return ErrIntOverflowGenerated
5983                                 }
5984                                 if iNdEx >= l {
5985                                         return io.ErrUnexpectedEOF
5986                                 }
5987                                 b := dAtA[iNdEx]
5988                                 iNdEx++
5989                                 stringLen |= (uint64(b) & 0x7F) << shift
5990                                 if b < 0x80 {
5991                                         break
5992                                 }
5993                         }
5994                         intStringLen := int(stringLen)
5995                         if intStringLen < 0 {
5996                                 return ErrInvalidLengthGenerated
5997                         }
5998                         postIndex := iNdEx + intStringLen
5999                         if postIndex > l {
6000                                 return io.ErrUnexpectedEOF
6001                         }
6002                         m.ResourceVersion = string(dAtA[iNdEx:postIndex])
6003                         iNdEx = postIndex
6004                 case 7:
6005                         if wireType != 0 {
6006                                 return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)
6007                         }
6008                         m.Generation = 0
6009                         for shift := uint(0); ; shift += 7 {
6010                                 if shift >= 64 {
6011                                         return ErrIntOverflowGenerated
6012                                 }
6013                                 if iNdEx >= l {
6014                                         return io.ErrUnexpectedEOF
6015                                 }
6016                                 b := dAtA[iNdEx]
6017                                 iNdEx++
6018                                 m.Generation |= (int64(b) & 0x7F) << shift
6019                                 if b < 0x80 {
6020                                         break
6021                                 }
6022                         }
6023                 case 8:
6024                         if wireType != 2 {
6025                                 return fmt.Errorf("proto: wrong wireType = %d for field CreationTimestamp", wireType)
6026                         }
6027                         var msglen int
6028                         for shift := uint(0); ; shift += 7 {
6029                                 if shift >= 64 {
6030                                         return ErrIntOverflowGenerated
6031                                 }
6032                                 if iNdEx >= l {
6033                                         return io.ErrUnexpectedEOF
6034                                 }
6035                                 b := dAtA[iNdEx]
6036                                 iNdEx++
6037                                 msglen |= (int(b) & 0x7F) << shift
6038                                 if b < 0x80 {
6039                                         break
6040                                 }
6041                         }
6042                         if msglen < 0 {
6043                                 return ErrInvalidLengthGenerated
6044                         }
6045                         postIndex := iNdEx + msglen
6046                         if postIndex > l {
6047                                 return io.ErrUnexpectedEOF
6048                         }
6049                         if err := m.CreationTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6050                                 return err
6051                         }
6052                         iNdEx = postIndex
6053                 case 9:
6054                         if wireType != 2 {
6055                                 return fmt.Errorf("proto: wrong wireType = %d for field DeletionTimestamp", wireType)
6056                         }
6057                         var msglen int
6058                         for shift := uint(0); ; shift += 7 {
6059                                 if shift >= 64 {
6060                                         return ErrIntOverflowGenerated
6061                                 }
6062                                 if iNdEx >= l {
6063                                         return io.ErrUnexpectedEOF
6064                                 }
6065                                 b := dAtA[iNdEx]
6066                                 iNdEx++
6067                                 msglen |= (int(b) & 0x7F) << shift
6068                                 if b < 0x80 {
6069                                         break
6070                                 }
6071                         }
6072                         if msglen < 0 {
6073                                 return ErrInvalidLengthGenerated
6074                         }
6075                         postIndex := iNdEx + msglen
6076                         if postIndex > l {
6077                                 return io.ErrUnexpectedEOF
6078                         }
6079                         if m.DeletionTimestamp == nil {
6080                                 m.DeletionTimestamp = &Time{}
6081                         }
6082                         if err := m.DeletionTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6083                                 return err
6084                         }
6085                         iNdEx = postIndex
6086                 case 10:
6087                         if wireType != 0 {
6088                                 return fmt.Errorf("proto: wrong wireType = %d for field DeletionGracePeriodSeconds", wireType)
6089                         }
6090                         var v int64
6091                         for shift := uint(0); ; shift += 7 {
6092                                 if shift >= 64 {
6093                                         return ErrIntOverflowGenerated
6094                                 }
6095                                 if iNdEx >= l {
6096                                         return io.ErrUnexpectedEOF
6097                                 }
6098                                 b := dAtA[iNdEx]
6099                                 iNdEx++
6100                                 v |= (int64(b) & 0x7F) << shift
6101                                 if b < 0x80 {
6102                                         break
6103                                 }
6104                         }
6105                         m.DeletionGracePeriodSeconds = &v
6106                 case 11:
6107                         if wireType != 2 {
6108                                 return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
6109                         }
6110                         var msglen int
6111                         for shift := uint(0); ; shift += 7 {
6112                                 if shift >= 64 {
6113                                         return ErrIntOverflowGenerated
6114                                 }
6115                                 if iNdEx >= l {
6116                                         return io.ErrUnexpectedEOF
6117                                 }
6118                                 b := dAtA[iNdEx]
6119                                 iNdEx++
6120                                 msglen |= (int(b) & 0x7F) << shift
6121                                 if b < 0x80 {
6122                                         break
6123                                 }
6124                         }
6125                         if msglen < 0 {
6126                                 return ErrInvalidLengthGenerated
6127                         }
6128                         postIndex := iNdEx + msglen
6129                         if postIndex > l {
6130                                 return io.ErrUnexpectedEOF
6131                         }
6132                         if m.Labels == nil {
6133                                 m.Labels = make(map[string]string)
6134                         }
6135                         var mapkey string
6136                         var mapvalue string
6137                         for iNdEx < postIndex {
6138                                 entryPreIndex := iNdEx
6139                                 var wire uint64
6140                                 for shift := uint(0); ; shift += 7 {
6141                                         if shift >= 64 {
6142                                                 return ErrIntOverflowGenerated
6143                                         }
6144                                         if iNdEx >= l {
6145                                                 return io.ErrUnexpectedEOF
6146                                         }
6147                                         b := dAtA[iNdEx]
6148                                         iNdEx++
6149                                         wire |= (uint64(b) & 0x7F) << shift
6150                                         if b < 0x80 {
6151                                                 break
6152                                         }
6153                                 }
6154                                 fieldNum := int32(wire >> 3)
6155                                 if fieldNum == 1 {
6156                                         var stringLenmapkey uint64
6157                                         for shift := uint(0); ; shift += 7 {
6158                                                 if shift >= 64 {
6159                                                         return ErrIntOverflowGenerated
6160                                                 }
6161                                                 if iNdEx >= l {
6162                                                         return io.ErrUnexpectedEOF
6163                                                 }
6164                                                 b := dAtA[iNdEx]
6165                                                 iNdEx++
6166                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6167                                                 if b < 0x80 {
6168                                                         break
6169                                                 }
6170                                         }
6171                                         intStringLenmapkey := int(stringLenmapkey)
6172                                         if intStringLenmapkey < 0 {
6173                                                 return ErrInvalidLengthGenerated
6174                                         }
6175                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
6176                                         if postStringIndexmapkey > l {
6177                                                 return io.ErrUnexpectedEOF
6178                                         }
6179                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6180                                         iNdEx = postStringIndexmapkey
6181                                 } else if fieldNum == 2 {
6182                                         var stringLenmapvalue uint64
6183                                         for shift := uint(0); ; shift += 7 {
6184                                                 if shift >= 64 {
6185                                                         return ErrIntOverflowGenerated
6186                                                 }
6187                                                 if iNdEx >= l {
6188                                                         return io.ErrUnexpectedEOF
6189                                                 }
6190                                                 b := dAtA[iNdEx]
6191                                                 iNdEx++
6192                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6193                                                 if b < 0x80 {
6194                                                         break
6195                                                 }
6196                                         }
6197                                         intStringLenmapvalue := int(stringLenmapvalue)
6198                                         if intStringLenmapvalue < 0 {
6199                                                 return ErrInvalidLengthGenerated
6200                                         }
6201                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6202                                         if postStringIndexmapvalue > l {
6203                                                 return io.ErrUnexpectedEOF
6204                                         }
6205                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6206                                         iNdEx = postStringIndexmapvalue
6207                                 } else {
6208                                         iNdEx = entryPreIndex
6209                                         skippy, err := skipGenerated(dAtA[iNdEx:])
6210                                         if err != nil {
6211                                                 return err
6212                                         }
6213                                         if skippy < 0 {
6214                                                 return ErrInvalidLengthGenerated
6215                                         }
6216                                         if (iNdEx + skippy) > postIndex {
6217                                                 return io.ErrUnexpectedEOF
6218                                         }
6219                                         iNdEx += skippy
6220                                 }
6221                         }
6222                         m.Labels[mapkey] = mapvalue
6223                         iNdEx = postIndex
6224                 case 12:
6225                         if wireType != 2 {
6226                                 return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
6227                         }
6228                         var msglen int
6229                         for shift := uint(0); ; shift += 7 {
6230                                 if shift >= 64 {
6231                                         return ErrIntOverflowGenerated
6232                                 }
6233                                 if iNdEx >= l {
6234                                         return io.ErrUnexpectedEOF
6235                                 }
6236                                 b := dAtA[iNdEx]
6237                                 iNdEx++
6238                                 msglen |= (int(b) & 0x7F) << shift
6239                                 if b < 0x80 {
6240                                         break
6241                                 }
6242                         }
6243                         if msglen < 0 {
6244                                 return ErrInvalidLengthGenerated
6245                         }
6246                         postIndex := iNdEx + msglen
6247                         if postIndex > l {
6248                                 return io.ErrUnexpectedEOF
6249                         }
6250                         if m.Annotations == nil {
6251                                 m.Annotations = make(map[string]string)
6252                         }
6253                         var mapkey string
6254                         var mapvalue string
6255                         for iNdEx < postIndex {
6256                                 entryPreIndex := iNdEx
6257                                 var wire uint64
6258                                 for shift := uint(0); ; shift += 7 {
6259                                         if shift >= 64 {
6260                                                 return ErrIntOverflowGenerated
6261                                         }
6262                                         if iNdEx >= l {
6263                                                 return io.ErrUnexpectedEOF
6264                                         }
6265                                         b := dAtA[iNdEx]
6266                                         iNdEx++
6267                                         wire |= (uint64(b) & 0x7F) << shift
6268                                         if b < 0x80 {
6269                                                 break
6270                                         }
6271                                 }
6272                                 fieldNum := int32(wire >> 3)
6273                                 if fieldNum == 1 {
6274                                         var stringLenmapkey uint64
6275                                         for shift := uint(0); ; shift += 7 {
6276                                                 if shift >= 64 {
6277                                                         return ErrIntOverflowGenerated
6278                                                 }
6279                                                 if iNdEx >= l {
6280                                                         return io.ErrUnexpectedEOF
6281                                                 }
6282                                                 b := dAtA[iNdEx]
6283                                                 iNdEx++
6284                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6285                                                 if b < 0x80 {
6286                                                         break
6287                                                 }
6288                                         }
6289                                         intStringLenmapkey := int(stringLenmapkey)
6290                                         if intStringLenmapkey < 0 {
6291                                                 return ErrInvalidLengthGenerated
6292                                         }
6293                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
6294                                         if postStringIndexmapkey > l {
6295                                                 return io.ErrUnexpectedEOF
6296                                         }
6297                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6298                                         iNdEx = postStringIndexmapkey
6299                                 } else if fieldNum == 2 {
6300                                         var stringLenmapvalue uint64
6301                                         for shift := uint(0); ; shift += 7 {
6302                                                 if shift >= 64 {
6303                                                         return ErrIntOverflowGenerated
6304                                                 }
6305                                                 if iNdEx >= l {
6306                                                         return io.ErrUnexpectedEOF
6307                                                 }
6308                                                 b := dAtA[iNdEx]
6309                                                 iNdEx++
6310                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6311                                                 if b < 0x80 {
6312                                                         break
6313                                                 }
6314                                         }
6315                                         intStringLenmapvalue := int(stringLenmapvalue)
6316                                         if intStringLenmapvalue < 0 {
6317                                                 return ErrInvalidLengthGenerated
6318                                         }
6319                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6320                                         if postStringIndexmapvalue > l {
6321                                                 return io.ErrUnexpectedEOF
6322                                         }
6323                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6324                                         iNdEx = postStringIndexmapvalue
6325                                 } else {
6326                                         iNdEx = entryPreIndex
6327                                         skippy, err := skipGenerated(dAtA[iNdEx:])
6328                                         if err != nil {
6329                                                 return err
6330                                         }
6331                                         if skippy < 0 {
6332                                                 return ErrInvalidLengthGenerated
6333                                         }
6334                                         if (iNdEx + skippy) > postIndex {
6335                                                 return io.ErrUnexpectedEOF
6336                                         }
6337                                         iNdEx += skippy
6338                                 }
6339                         }
6340                         m.Annotations[mapkey] = mapvalue
6341                         iNdEx = postIndex
6342                 case 13:
6343                         if wireType != 2 {
6344                                 return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
6345                         }
6346                         var msglen int
6347                         for shift := uint(0); ; shift += 7 {
6348                                 if shift >= 64 {
6349                                         return ErrIntOverflowGenerated
6350                                 }
6351                                 if iNdEx >= l {
6352                                         return io.ErrUnexpectedEOF
6353                                 }
6354                                 b := dAtA[iNdEx]
6355                                 iNdEx++
6356                                 msglen |= (int(b) & 0x7F) << shift
6357                                 if b < 0x80 {
6358                                         break
6359                                 }
6360                         }
6361                         if msglen < 0 {
6362                                 return ErrInvalidLengthGenerated
6363                         }
6364                         postIndex := iNdEx + msglen
6365                         if postIndex > l {
6366                                 return io.ErrUnexpectedEOF
6367                         }
6368                         m.OwnerReferences = append(m.OwnerReferences, OwnerReference{})
6369                         if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6370                                 return err
6371                         }
6372                         iNdEx = postIndex
6373                 case 14:
6374                         if wireType != 2 {
6375                                 return fmt.Errorf("proto: wrong wireType = %d for field Finalizers", wireType)
6376                         }
6377                         var stringLen uint64
6378                         for shift := uint(0); ; shift += 7 {
6379                                 if shift >= 64 {
6380                                         return ErrIntOverflowGenerated
6381                                 }
6382                                 if iNdEx >= l {
6383                                         return io.ErrUnexpectedEOF
6384                                 }
6385                                 b := dAtA[iNdEx]
6386                                 iNdEx++
6387                                 stringLen |= (uint64(b) & 0x7F) << shift
6388                                 if b < 0x80 {
6389                                         break
6390                                 }
6391                         }
6392                         intStringLen := int(stringLen)
6393                         if intStringLen < 0 {
6394                                 return ErrInvalidLengthGenerated
6395                         }
6396                         postIndex := iNdEx + intStringLen
6397                         if postIndex > l {
6398                                 return io.ErrUnexpectedEOF
6399                         }
6400                         m.Finalizers = append(m.Finalizers, string(dAtA[iNdEx:postIndex]))
6401                         iNdEx = postIndex
6402                 case 15:
6403                         if wireType != 2 {
6404                                 return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
6405                         }
6406                         var stringLen uint64
6407                         for shift := uint(0); ; shift += 7 {
6408                                 if shift >= 64 {
6409                                         return ErrIntOverflowGenerated
6410                                 }
6411                                 if iNdEx >= l {
6412                                         return io.ErrUnexpectedEOF
6413                                 }
6414                                 b := dAtA[iNdEx]
6415                                 iNdEx++
6416                                 stringLen |= (uint64(b) & 0x7F) << shift
6417                                 if b < 0x80 {
6418                                         break
6419                                 }
6420                         }
6421                         intStringLen := int(stringLen)
6422                         if intStringLen < 0 {
6423                                 return ErrInvalidLengthGenerated
6424                         }
6425                         postIndex := iNdEx + intStringLen
6426                         if postIndex > l {
6427                                 return io.ErrUnexpectedEOF
6428                         }
6429                         m.ClusterName = string(dAtA[iNdEx:postIndex])
6430                         iNdEx = postIndex
6431                 case 16:
6432                         if wireType != 2 {
6433                                 return fmt.Errorf("proto: wrong wireType = %d for field Initializers", wireType)
6434                         }
6435                         var msglen int
6436                         for shift := uint(0); ; shift += 7 {
6437                                 if shift >= 64 {
6438                                         return ErrIntOverflowGenerated
6439                                 }
6440                                 if iNdEx >= l {
6441                                         return io.ErrUnexpectedEOF
6442                                 }
6443                                 b := dAtA[iNdEx]
6444                                 iNdEx++
6445                                 msglen |= (int(b) & 0x7F) << shift
6446                                 if b < 0x80 {
6447                                         break
6448                                 }
6449                         }
6450                         if msglen < 0 {
6451                                 return ErrInvalidLengthGenerated
6452                         }
6453                         postIndex := iNdEx + msglen
6454                         if postIndex > l {
6455                                 return io.ErrUnexpectedEOF
6456                         }
6457                         if m.Initializers == nil {
6458                                 m.Initializers = &Initializers{}
6459                         }
6460                         if err := m.Initializers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6461                                 return err
6462                         }
6463                         iNdEx = postIndex
6464                 default:
6465                         iNdEx = preIndex
6466                         skippy, err := skipGenerated(dAtA[iNdEx:])
6467                         if err != nil {
6468                                 return err
6469                         }
6470                         if skippy < 0 {
6471                                 return ErrInvalidLengthGenerated
6472                         }
6473                         if (iNdEx + skippy) > l {
6474                                 return io.ErrUnexpectedEOF
6475                         }
6476                         iNdEx += skippy
6477                 }
6478         }
6479
6480         if iNdEx > l {
6481                 return io.ErrUnexpectedEOF
6482         }
6483         return nil
6484 }
6485 func (m *OwnerReference) Unmarshal(dAtA []byte) error {
6486         l := len(dAtA)
6487         iNdEx := 0
6488         for iNdEx < l {
6489                 preIndex := iNdEx
6490                 var wire uint64
6491                 for shift := uint(0); ; shift += 7 {
6492                         if shift >= 64 {
6493                                 return ErrIntOverflowGenerated
6494                         }
6495                         if iNdEx >= l {
6496                                 return io.ErrUnexpectedEOF
6497                         }
6498                         b := dAtA[iNdEx]
6499                         iNdEx++
6500                         wire |= (uint64(b) & 0x7F) << shift
6501                         if b < 0x80 {
6502                                 break
6503                         }
6504                 }
6505                 fieldNum := int32(wire >> 3)
6506                 wireType := int(wire & 0x7)
6507                 if wireType == 4 {
6508                         return fmt.Errorf("proto: OwnerReference: wiretype end group for non-group")
6509                 }
6510                 if fieldNum <= 0 {
6511                         return fmt.Errorf("proto: OwnerReference: illegal tag %d (wire type %d)", fieldNum, wire)
6512                 }
6513                 switch fieldNum {
6514                 case 1:
6515                         if wireType != 2 {
6516                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
6517                         }
6518                         var stringLen uint64
6519                         for shift := uint(0); ; shift += 7 {
6520                                 if shift >= 64 {
6521                                         return ErrIntOverflowGenerated
6522                                 }
6523                                 if iNdEx >= l {
6524                                         return io.ErrUnexpectedEOF
6525                                 }
6526                                 b := dAtA[iNdEx]
6527                                 iNdEx++
6528                                 stringLen |= (uint64(b) & 0x7F) << shift
6529                                 if b < 0x80 {
6530                                         break
6531                                 }
6532                         }
6533                         intStringLen := int(stringLen)
6534                         if intStringLen < 0 {
6535                                 return ErrInvalidLengthGenerated
6536                         }
6537                         postIndex := iNdEx + intStringLen
6538                         if postIndex > l {
6539                                 return io.ErrUnexpectedEOF
6540                         }
6541                         m.Kind = string(dAtA[iNdEx:postIndex])
6542                         iNdEx = postIndex
6543                 case 3:
6544                         if wireType != 2 {
6545                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6546                         }
6547                         var stringLen uint64
6548                         for shift := uint(0); ; shift += 7 {
6549                                 if shift >= 64 {
6550                                         return ErrIntOverflowGenerated
6551                                 }
6552                                 if iNdEx >= l {
6553                                         return io.ErrUnexpectedEOF
6554                                 }
6555                                 b := dAtA[iNdEx]
6556                                 iNdEx++
6557                                 stringLen |= (uint64(b) & 0x7F) << shift
6558                                 if b < 0x80 {
6559                                         break
6560                                 }
6561                         }
6562                         intStringLen := int(stringLen)
6563                         if intStringLen < 0 {
6564                                 return ErrInvalidLengthGenerated
6565                         }
6566                         postIndex := iNdEx + intStringLen
6567                         if postIndex > l {
6568                                 return io.ErrUnexpectedEOF
6569                         }
6570                         m.Name = string(dAtA[iNdEx:postIndex])
6571                         iNdEx = postIndex
6572                 case 4:
6573                         if wireType != 2 {
6574                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
6575                         }
6576                         var stringLen uint64
6577                         for shift := uint(0); ; shift += 7 {
6578                                 if shift >= 64 {
6579                                         return ErrIntOverflowGenerated
6580                                 }
6581                                 if iNdEx >= l {
6582                                         return io.ErrUnexpectedEOF
6583                                 }
6584                                 b := dAtA[iNdEx]
6585                                 iNdEx++
6586                                 stringLen |= (uint64(b) & 0x7F) << shift
6587                                 if b < 0x80 {
6588                                         break
6589                                 }
6590                         }
6591                         intStringLen := int(stringLen)
6592                         if intStringLen < 0 {
6593                                 return ErrInvalidLengthGenerated
6594                         }
6595                         postIndex := iNdEx + intStringLen
6596                         if postIndex > l {
6597                                 return io.ErrUnexpectedEOF
6598                         }
6599                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
6600                         iNdEx = postIndex
6601                 case 5:
6602                         if wireType != 2 {
6603                                 return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
6604                         }
6605                         var stringLen uint64
6606                         for shift := uint(0); ; shift += 7 {
6607                                 if shift >= 64 {
6608                                         return ErrIntOverflowGenerated
6609                                 }
6610                                 if iNdEx >= l {
6611                                         return io.ErrUnexpectedEOF
6612                                 }
6613                                 b := dAtA[iNdEx]
6614                                 iNdEx++
6615                                 stringLen |= (uint64(b) & 0x7F) << shift
6616                                 if b < 0x80 {
6617                                         break
6618                                 }
6619                         }
6620                         intStringLen := int(stringLen)
6621                         if intStringLen < 0 {
6622                                 return ErrInvalidLengthGenerated
6623                         }
6624                         postIndex := iNdEx + intStringLen
6625                         if postIndex > l {
6626                                 return io.ErrUnexpectedEOF
6627                         }
6628                         m.APIVersion = string(dAtA[iNdEx:postIndex])
6629                         iNdEx = postIndex
6630                 case 6:
6631                         if wireType != 0 {
6632                                 return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
6633                         }
6634                         var v int
6635                         for shift := uint(0); ; shift += 7 {
6636                                 if shift >= 64 {
6637                                         return ErrIntOverflowGenerated
6638                                 }
6639                                 if iNdEx >= l {
6640                                         return io.ErrUnexpectedEOF
6641                                 }
6642                                 b := dAtA[iNdEx]
6643                                 iNdEx++
6644                                 v |= (int(b) & 0x7F) << shift
6645                                 if b < 0x80 {
6646                                         break
6647                                 }
6648                         }
6649                         b := bool(v != 0)
6650                         m.Controller = &b
6651                 case 7:
6652                         if wireType != 0 {
6653                                 return fmt.Errorf("proto: wrong wireType = %d for field BlockOwnerDeletion", wireType)
6654                         }
6655                         var v int
6656                         for shift := uint(0); ; shift += 7 {
6657                                 if shift >= 64 {
6658                                         return ErrIntOverflowGenerated
6659                                 }
6660                                 if iNdEx >= l {
6661                                         return io.ErrUnexpectedEOF
6662                                 }
6663                                 b := dAtA[iNdEx]
6664                                 iNdEx++
6665                                 v |= (int(b) & 0x7F) << shift
6666                                 if b < 0x80 {
6667                                         break
6668                                 }
6669                         }
6670                         b := bool(v != 0)
6671                         m.BlockOwnerDeletion = &b
6672                 default:
6673                         iNdEx = preIndex
6674                         skippy, err := skipGenerated(dAtA[iNdEx:])
6675                         if err != nil {
6676                                 return err
6677                         }
6678                         if skippy < 0 {
6679                                 return ErrInvalidLengthGenerated
6680                         }
6681                         if (iNdEx + skippy) > l {
6682                                 return io.ErrUnexpectedEOF
6683                         }
6684                         iNdEx += skippy
6685                 }
6686         }
6687
6688         if iNdEx > l {
6689                 return io.ErrUnexpectedEOF
6690         }
6691         return nil
6692 }
6693 func (m *Patch) Unmarshal(dAtA []byte) error {
6694         l := len(dAtA)
6695         iNdEx := 0
6696         for iNdEx < l {
6697                 preIndex := iNdEx
6698                 var wire uint64
6699                 for shift := uint(0); ; shift += 7 {
6700                         if shift >= 64 {
6701                                 return ErrIntOverflowGenerated
6702                         }
6703                         if iNdEx >= l {
6704                                 return io.ErrUnexpectedEOF
6705                         }
6706                         b := dAtA[iNdEx]
6707                         iNdEx++
6708                         wire |= (uint64(b) & 0x7F) << shift
6709                         if b < 0x80 {
6710                                 break
6711                         }
6712                 }
6713                 fieldNum := int32(wire >> 3)
6714                 wireType := int(wire & 0x7)
6715                 if wireType == 4 {
6716                         return fmt.Errorf("proto: Patch: wiretype end group for non-group")
6717                 }
6718                 if fieldNum <= 0 {
6719                         return fmt.Errorf("proto: Patch: illegal tag %d (wire type %d)", fieldNum, wire)
6720                 }
6721                 switch fieldNum {
6722                 default:
6723                         iNdEx = preIndex
6724                         skippy, err := skipGenerated(dAtA[iNdEx:])
6725                         if err != nil {
6726                                 return err
6727                         }
6728                         if skippy < 0 {
6729                                 return ErrInvalidLengthGenerated
6730                         }
6731                         if (iNdEx + skippy) > l {
6732                                 return io.ErrUnexpectedEOF
6733                         }
6734                         iNdEx += skippy
6735                 }
6736         }
6737
6738         if iNdEx > l {
6739                 return io.ErrUnexpectedEOF
6740         }
6741         return nil
6742 }
6743 func (m *Preconditions) Unmarshal(dAtA []byte) error {
6744         l := len(dAtA)
6745         iNdEx := 0
6746         for iNdEx < l {
6747                 preIndex := iNdEx
6748                 var wire uint64
6749                 for shift := uint(0); ; shift += 7 {
6750                         if shift >= 64 {
6751                                 return ErrIntOverflowGenerated
6752                         }
6753                         if iNdEx >= l {
6754                                 return io.ErrUnexpectedEOF
6755                         }
6756                         b := dAtA[iNdEx]
6757                         iNdEx++
6758                         wire |= (uint64(b) & 0x7F) << shift
6759                         if b < 0x80 {
6760                                 break
6761                         }
6762                 }
6763                 fieldNum := int32(wire >> 3)
6764                 wireType := int(wire & 0x7)
6765                 if wireType == 4 {
6766                         return fmt.Errorf("proto: Preconditions: wiretype end group for non-group")
6767                 }
6768                 if fieldNum <= 0 {
6769                         return fmt.Errorf("proto: Preconditions: illegal tag %d (wire type %d)", fieldNum, wire)
6770                 }
6771                 switch fieldNum {
6772                 case 1:
6773                         if wireType != 2 {
6774                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
6775                         }
6776                         var stringLen uint64
6777                         for shift := uint(0); ; shift += 7 {
6778                                 if shift >= 64 {
6779                                         return ErrIntOverflowGenerated
6780                                 }
6781                                 if iNdEx >= l {
6782                                         return io.ErrUnexpectedEOF
6783                                 }
6784                                 b := dAtA[iNdEx]
6785                                 iNdEx++
6786                                 stringLen |= (uint64(b) & 0x7F) << shift
6787                                 if b < 0x80 {
6788                                         break
6789                                 }
6790                         }
6791                         intStringLen := int(stringLen)
6792                         if intStringLen < 0 {
6793                                 return ErrInvalidLengthGenerated
6794                         }
6795                         postIndex := iNdEx + intStringLen
6796                         if postIndex > l {
6797                                 return io.ErrUnexpectedEOF
6798                         }
6799                         s := k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
6800                         m.UID = &s
6801                         iNdEx = postIndex
6802                 default:
6803                         iNdEx = preIndex
6804                         skippy, err := skipGenerated(dAtA[iNdEx:])
6805                         if err != nil {
6806                                 return err
6807                         }
6808                         if skippy < 0 {
6809                                 return ErrInvalidLengthGenerated
6810                         }
6811                         if (iNdEx + skippy) > l {
6812                                 return io.ErrUnexpectedEOF
6813                         }
6814                         iNdEx += skippy
6815                 }
6816         }
6817
6818         if iNdEx > l {
6819                 return io.ErrUnexpectedEOF
6820         }
6821         return nil
6822 }
6823 func (m *RootPaths) Unmarshal(dAtA []byte) error {
6824         l := len(dAtA)
6825         iNdEx := 0
6826         for iNdEx < l {
6827                 preIndex := iNdEx
6828                 var wire uint64
6829                 for shift := uint(0); ; shift += 7 {
6830                         if shift >= 64 {
6831                                 return ErrIntOverflowGenerated
6832                         }
6833                         if iNdEx >= l {
6834                                 return io.ErrUnexpectedEOF
6835                         }
6836                         b := dAtA[iNdEx]
6837                         iNdEx++
6838                         wire |= (uint64(b) & 0x7F) << shift
6839                         if b < 0x80 {
6840                                 break
6841                         }
6842                 }
6843                 fieldNum := int32(wire >> 3)
6844                 wireType := int(wire & 0x7)
6845                 if wireType == 4 {
6846                         return fmt.Errorf("proto: RootPaths: wiretype end group for non-group")
6847                 }
6848                 if fieldNum <= 0 {
6849                         return fmt.Errorf("proto: RootPaths: illegal tag %d (wire type %d)", fieldNum, wire)
6850                 }
6851                 switch fieldNum {
6852                 case 1:
6853                         if wireType != 2 {
6854                                 return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
6855                         }
6856                         var stringLen uint64
6857                         for shift := uint(0); ; shift += 7 {
6858                                 if shift >= 64 {
6859                                         return ErrIntOverflowGenerated
6860                                 }
6861                                 if iNdEx >= l {
6862                                         return io.ErrUnexpectedEOF
6863                                 }
6864                                 b := dAtA[iNdEx]
6865                                 iNdEx++
6866                                 stringLen |= (uint64(b) & 0x7F) << shift
6867                                 if b < 0x80 {
6868                                         break
6869                                 }
6870                         }
6871                         intStringLen := int(stringLen)
6872                         if intStringLen < 0 {
6873                                 return ErrInvalidLengthGenerated
6874                         }
6875                         postIndex := iNdEx + intStringLen
6876                         if postIndex > l {
6877                                 return io.ErrUnexpectedEOF
6878                         }
6879                         m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
6880                         iNdEx = postIndex
6881                 default:
6882                         iNdEx = preIndex
6883                         skippy, err := skipGenerated(dAtA[iNdEx:])
6884                         if err != nil {
6885                                 return err
6886                         }
6887                         if skippy < 0 {
6888                                 return ErrInvalidLengthGenerated
6889                         }
6890                         if (iNdEx + skippy) > l {
6891                                 return io.ErrUnexpectedEOF
6892                         }
6893                         iNdEx += skippy
6894                 }
6895         }
6896
6897         if iNdEx > l {
6898                 return io.ErrUnexpectedEOF
6899         }
6900         return nil
6901 }
6902 func (m *ServerAddressByClientCIDR) Unmarshal(dAtA []byte) error {
6903         l := len(dAtA)
6904         iNdEx := 0
6905         for iNdEx < l {
6906                 preIndex := iNdEx
6907                 var wire uint64
6908                 for shift := uint(0); ; shift += 7 {
6909                         if shift >= 64 {
6910                                 return ErrIntOverflowGenerated
6911                         }
6912                         if iNdEx >= l {
6913                                 return io.ErrUnexpectedEOF
6914                         }
6915                         b := dAtA[iNdEx]
6916                         iNdEx++
6917                         wire |= (uint64(b) & 0x7F) << shift
6918                         if b < 0x80 {
6919                                 break
6920                         }
6921                 }
6922                 fieldNum := int32(wire >> 3)
6923                 wireType := int(wire & 0x7)
6924                 if wireType == 4 {
6925                         return fmt.Errorf("proto: ServerAddressByClientCIDR: wiretype end group for non-group")
6926                 }
6927                 if fieldNum <= 0 {
6928                         return fmt.Errorf("proto: ServerAddressByClientCIDR: illegal tag %d (wire type %d)", fieldNum, wire)
6929                 }
6930                 switch fieldNum {
6931                 case 1:
6932                         if wireType != 2 {
6933                                 return fmt.Errorf("proto: wrong wireType = %d for field ClientCIDR", wireType)
6934                         }
6935                         var stringLen uint64
6936                         for shift := uint(0); ; shift += 7 {
6937                                 if shift >= 64 {
6938                                         return ErrIntOverflowGenerated
6939                                 }
6940                                 if iNdEx >= l {
6941                                         return io.ErrUnexpectedEOF
6942                                 }
6943                                 b := dAtA[iNdEx]
6944                                 iNdEx++
6945                                 stringLen |= (uint64(b) & 0x7F) << shift
6946                                 if b < 0x80 {
6947                                         break
6948                                 }
6949                         }
6950                         intStringLen := int(stringLen)
6951                         if intStringLen < 0 {
6952                                 return ErrInvalidLengthGenerated
6953                         }
6954                         postIndex := iNdEx + intStringLen
6955                         if postIndex > l {
6956                                 return io.ErrUnexpectedEOF
6957                         }
6958                         m.ClientCIDR = string(dAtA[iNdEx:postIndex])
6959                         iNdEx = postIndex
6960                 case 2:
6961                         if wireType != 2 {
6962                                 return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", wireType)
6963                         }
6964                         var stringLen uint64
6965                         for shift := uint(0); ; shift += 7 {
6966                                 if shift >= 64 {
6967                                         return ErrIntOverflowGenerated
6968                                 }
6969                                 if iNdEx >= l {
6970                                         return io.ErrUnexpectedEOF
6971                                 }
6972                                 b := dAtA[iNdEx]
6973                                 iNdEx++
6974                                 stringLen |= (uint64(b) & 0x7F) << shift
6975                                 if b < 0x80 {
6976                                         break
6977                                 }
6978                         }
6979                         intStringLen := int(stringLen)
6980                         if intStringLen < 0 {
6981                                 return ErrInvalidLengthGenerated
6982                         }
6983                         postIndex := iNdEx + intStringLen
6984                         if postIndex > l {
6985                                 return io.ErrUnexpectedEOF
6986                         }
6987                         m.ServerAddress = string(dAtA[iNdEx:postIndex])
6988                         iNdEx = postIndex
6989                 default:
6990                         iNdEx = preIndex
6991                         skippy, err := skipGenerated(dAtA[iNdEx:])
6992                         if err != nil {
6993                                 return err
6994                         }
6995                         if skippy < 0 {
6996                                 return ErrInvalidLengthGenerated
6997                         }
6998                         if (iNdEx + skippy) > l {
6999                                 return io.ErrUnexpectedEOF
7000                         }
7001                         iNdEx += skippy
7002                 }
7003         }
7004
7005         if iNdEx > l {
7006                 return io.ErrUnexpectedEOF
7007         }
7008         return nil
7009 }
7010 func (m *Status) Unmarshal(dAtA []byte) error {
7011         l := len(dAtA)
7012         iNdEx := 0
7013         for iNdEx < l {
7014                 preIndex := iNdEx
7015                 var wire uint64
7016                 for shift := uint(0); ; shift += 7 {
7017                         if shift >= 64 {
7018                                 return ErrIntOverflowGenerated
7019                         }
7020                         if iNdEx >= l {
7021                                 return io.ErrUnexpectedEOF
7022                         }
7023                         b := dAtA[iNdEx]
7024                         iNdEx++
7025                         wire |= (uint64(b) & 0x7F) << shift
7026                         if b < 0x80 {
7027                                 break
7028                         }
7029                 }
7030                 fieldNum := int32(wire >> 3)
7031                 wireType := int(wire & 0x7)
7032                 if wireType == 4 {
7033                         return fmt.Errorf("proto: Status: wiretype end group for non-group")
7034                 }
7035                 if fieldNum <= 0 {
7036                         return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
7037                 }
7038                 switch fieldNum {
7039                 case 1:
7040                         if wireType != 2 {
7041                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
7042                         }
7043                         var msglen int
7044                         for shift := uint(0); ; shift += 7 {
7045                                 if shift >= 64 {
7046                                         return ErrIntOverflowGenerated
7047                                 }
7048                                 if iNdEx >= l {
7049                                         return io.ErrUnexpectedEOF
7050                                 }
7051                                 b := dAtA[iNdEx]
7052                                 iNdEx++
7053                                 msglen |= (int(b) & 0x7F) << shift
7054                                 if b < 0x80 {
7055                                         break
7056                                 }
7057                         }
7058                         if msglen < 0 {
7059                                 return ErrInvalidLengthGenerated
7060                         }
7061                         postIndex := iNdEx + msglen
7062                         if postIndex > l {
7063                                 return io.ErrUnexpectedEOF
7064                         }
7065                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7066                                 return err
7067                         }
7068                         iNdEx = postIndex
7069                 case 2:
7070                         if wireType != 2 {
7071                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7072                         }
7073                         var stringLen uint64
7074                         for shift := uint(0); ; shift += 7 {
7075                                 if shift >= 64 {
7076                                         return ErrIntOverflowGenerated
7077                                 }
7078                                 if iNdEx >= l {
7079                                         return io.ErrUnexpectedEOF
7080                                 }
7081                                 b := dAtA[iNdEx]
7082                                 iNdEx++
7083                                 stringLen |= (uint64(b) & 0x7F) << shift
7084                                 if b < 0x80 {
7085                                         break
7086                                 }
7087                         }
7088                         intStringLen := int(stringLen)
7089                         if intStringLen < 0 {
7090                                 return ErrInvalidLengthGenerated
7091                         }
7092                         postIndex := iNdEx + intStringLen
7093                         if postIndex > l {
7094                                 return io.ErrUnexpectedEOF
7095                         }
7096                         m.Status = string(dAtA[iNdEx:postIndex])
7097                         iNdEx = postIndex
7098                 case 3:
7099                         if wireType != 2 {
7100                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
7101                         }
7102                         var stringLen uint64
7103                         for shift := uint(0); ; shift += 7 {
7104                                 if shift >= 64 {
7105                                         return ErrIntOverflowGenerated
7106                                 }
7107                                 if iNdEx >= l {
7108                                         return io.ErrUnexpectedEOF
7109                                 }
7110                                 b := dAtA[iNdEx]
7111                                 iNdEx++
7112                                 stringLen |= (uint64(b) & 0x7F) << shift
7113                                 if b < 0x80 {
7114                                         break
7115                                 }
7116                         }
7117                         intStringLen := int(stringLen)
7118                         if intStringLen < 0 {
7119                                 return ErrInvalidLengthGenerated
7120                         }
7121                         postIndex := iNdEx + intStringLen
7122                         if postIndex > l {
7123                                 return io.ErrUnexpectedEOF
7124                         }
7125                         m.Message = string(dAtA[iNdEx:postIndex])
7126                         iNdEx = postIndex
7127                 case 4:
7128                         if wireType != 2 {
7129                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
7130                         }
7131                         var stringLen uint64
7132                         for shift := uint(0); ; shift += 7 {
7133                                 if shift >= 64 {
7134                                         return ErrIntOverflowGenerated
7135                                 }
7136                                 if iNdEx >= l {
7137                                         return io.ErrUnexpectedEOF
7138                                 }
7139                                 b := dAtA[iNdEx]
7140                                 iNdEx++
7141                                 stringLen |= (uint64(b) & 0x7F) << shift
7142                                 if b < 0x80 {
7143                                         break
7144                                 }
7145                         }
7146                         intStringLen := int(stringLen)
7147                         if intStringLen < 0 {
7148                                 return ErrInvalidLengthGenerated
7149                         }
7150                         postIndex := iNdEx + intStringLen
7151                         if postIndex > l {
7152                                 return io.ErrUnexpectedEOF
7153                         }
7154                         m.Reason = StatusReason(dAtA[iNdEx:postIndex])
7155                         iNdEx = postIndex
7156                 case 5:
7157                         if wireType != 2 {
7158                                 return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
7159                         }
7160                         var msglen int
7161                         for shift := uint(0); ; shift += 7 {
7162                                 if shift >= 64 {
7163                                         return ErrIntOverflowGenerated
7164                                 }
7165                                 if iNdEx >= l {
7166                                         return io.ErrUnexpectedEOF
7167                                 }
7168                                 b := dAtA[iNdEx]
7169                                 iNdEx++
7170                                 msglen |= (int(b) & 0x7F) << shift
7171                                 if b < 0x80 {
7172                                         break
7173                                 }
7174                         }
7175                         if msglen < 0 {
7176                                 return ErrInvalidLengthGenerated
7177                         }
7178                         postIndex := iNdEx + msglen
7179                         if postIndex > l {
7180                                 return io.ErrUnexpectedEOF
7181                         }
7182                         if m.Details == nil {
7183                                 m.Details = &StatusDetails{}
7184                         }
7185                         if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7186                                 return err
7187                         }
7188                         iNdEx = postIndex
7189                 case 6:
7190                         if wireType != 0 {
7191                                 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
7192                         }
7193                         m.Code = 0
7194                         for shift := uint(0); ; shift += 7 {
7195                                 if shift >= 64 {
7196                                         return ErrIntOverflowGenerated
7197                                 }
7198                                 if iNdEx >= l {
7199                                         return io.ErrUnexpectedEOF
7200                                 }
7201                                 b := dAtA[iNdEx]
7202                                 iNdEx++
7203                                 m.Code |= (int32(b) & 0x7F) << shift
7204                                 if b < 0x80 {
7205                                         break
7206                                 }
7207                         }
7208                 default:
7209                         iNdEx = preIndex
7210                         skippy, err := skipGenerated(dAtA[iNdEx:])
7211                         if err != nil {
7212                                 return err
7213                         }
7214                         if skippy < 0 {
7215                                 return ErrInvalidLengthGenerated
7216                         }
7217                         if (iNdEx + skippy) > l {
7218                                 return io.ErrUnexpectedEOF
7219                         }
7220                         iNdEx += skippy
7221                 }
7222         }
7223
7224         if iNdEx > l {
7225                 return io.ErrUnexpectedEOF
7226         }
7227         return nil
7228 }
7229 func (m *StatusCause) Unmarshal(dAtA []byte) error {
7230         l := len(dAtA)
7231         iNdEx := 0
7232         for iNdEx < l {
7233                 preIndex := iNdEx
7234                 var wire uint64
7235                 for shift := uint(0); ; shift += 7 {
7236                         if shift >= 64 {
7237                                 return ErrIntOverflowGenerated
7238                         }
7239                         if iNdEx >= l {
7240                                 return io.ErrUnexpectedEOF
7241                         }
7242                         b := dAtA[iNdEx]
7243                         iNdEx++
7244                         wire |= (uint64(b) & 0x7F) << shift
7245                         if b < 0x80 {
7246                                 break
7247                         }
7248                 }
7249                 fieldNum := int32(wire >> 3)
7250                 wireType := int(wire & 0x7)
7251                 if wireType == 4 {
7252                         return fmt.Errorf("proto: StatusCause: wiretype end group for non-group")
7253                 }
7254                 if fieldNum <= 0 {
7255                         return fmt.Errorf("proto: StatusCause: illegal tag %d (wire type %d)", fieldNum, wire)
7256                 }
7257                 switch fieldNum {
7258                 case 1:
7259                         if wireType != 2 {
7260                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7261                         }
7262                         var stringLen uint64
7263                         for shift := uint(0); ; shift += 7 {
7264                                 if shift >= 64 {
7265                                         return ErrIntOverflowGenerated
7266                                 }
7267                                 if iNdEx >= l {
7268                                         return io.ErrUnexpectedEOF
7269                                 }
7270                                 b := dAtA[iNdEx]
7271                                 iNdEx++
7272                                 stringLen |= (uint64(b) & 0x7F) << shift
7273                                 if b < 0x80 {
7274                                         break
7275                                 }
7276                         }
7277                         intStringLen := int(stringLen)
7278                         if intStringLen < 0 {
7279                                 return ErrInvalidLengthGenerated
7280                         }
7281                         postIndex := iNdEx + intStringLen
7282                         if postIndex > l {
7283                                 return io.ErrUnexpectedEOF
7284                         }
7285                         m.Type = CauseType(dAtA[iNdEx:postIndex])
7286                         iNdEx = postIndex
7287                 case 2:
7288                         if wireType != 2 {
7289                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
7290                         }
7291                         var stringLen uint64
7292                         for shift := uint(0); ; shift += 7 {
7293                                 if shift >= 64 {
7294                                         return ErrIntOverflowGenerated
7295                                 }
7296                                 if iNdEx >= l {
7297                                         return io.ErrUnexpectedEOF
7298                                 }
7299                                 b := dAtA[iNdEx]
7300                                 iNdEx++
7301                                 stringLen |= (uint64(b) & 0x7F) << shift
7302                                 if b < 0x80 {
7303                                         break
7304                                 }
7305                         }
7306                         intStringLen := int(stringLen)
7307                         if intStringLen < 0 {
7308                                 return ErrInvalidLengthGenerated
7309                         }
7310                         postIndex := iNdEx + intStringLen
7311                         if postIndex > l {
7312                                 return io.ErrUnexpectedEOF
7313                         }
7314                         m.Message = string(dAtA[iNdEx:postIndex])
7315                         iNdEx = postIndex
7316                 case 3:
7317                         if wireType != 2 {
7318                                 return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
7319                         }
7320                         var stringLen uint64
7321                         for shift := uint(0); ; shift += 7 {
7322                                 if shift >= 64 {
7323                                         return ErrIntOverflowGenerated
7324                                 }
7325                                 if iNdEx >= l {
7326                                         return io.ErrUnexpectedEOF
7327                                 }
7328                                 b := dAtA[iNdEx]
7329                                 iNdEx++
7330                                 stringLen |= (uint64(b) & 0x7F) << shift
7331                                 if b < 0x80 {
7332                                         break
7333                                 }
7334                         }
7335                         intStringLen := int(stringLen)
7336                         if intStringLen < 0 {
7337                                 return ErrInvalidLengthGenerated
7338                         }
7339                         postIndex := iNdEx + intStringLen
7340                         if postIndex > l {
7341                                 return io.ErrUnexpectedEOF
7342                         }
7343                         m.Field = string(dAtA[iNdEx:postIndex])
7344                         iNdEx = postIndex
7345                 default:
7346                         iNdEx = preIndex
7347                         skippy, err := skipGenerated(dAtA[iNdEx:])
7348                         if err != nil {
7349                                 return err
7350                         }
7351                         if skippy < 0 {
7352                                 return ErrInvalidLengthGenerated
7353                         }
7354                         if (iNdEx + skippy) > l {
7355                                 return io.ErrUnexpectedEOF
7356                         }
7357                         iNdEx += skippy
7358                 }
7359         }
7360
7361         if iNdEx > l {
7362                 return io.ErrUnexpectedEOF
7363         }
7364         return nil
7365 }
7366 func (m *StatusDetails) Unmarshal(dAtA []byte) error {
7367         l := len(dAtA)
7368         iNdEx := 0
7369         for iNdEx < l {
7370                 preIndex := iNdEx
7371                 var wire uint64
7372                 for shift := uint(0); ; shift += 7 {
7373                         if shift >= 64 {
7374                                 return ErrIntOverflowGenerated
7375                         }
7376                         if iNdEx >= l {
7377                                 return io.ErrUnexpectedEOF
7378                         }
7379                         b := dAtA[iNdEx]
7380                         iNdEx++
7381                         wire |= (uint64(b) & 0x7F) << shift
7382                         if b < 0x80 {
7383                                 break
7384                         }
7385                 }
7386                 fieldNum := int32(wire >> 3)
7387                 wireType := int(wire & 0x7)
7388                 if wireType == 4 {
7389                         return fmt.Errorf("proto: StatusDetails: wiretype end group for non-group")
7390                 }
7391                 if fieldNum <= 0 {
7392                         return fmt.Errorf("proto: StatusDetails: illegal tag %d (wire type %d)", fieldNum, wire)
7393                 }
7394                 switch fieldNum {
7395                 case 1:
7396                         if wireType != 2 {
7397                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
7398                         }
7399                         var stringLen uint64
7400                         for shift := uint(0); ; shift += 7 {
7401                                 if shift >= 64 {
7402                                         return ErrIntOverflowGenerated
7403                                 }
7404                                 if iNdEx >= l {
7405                                         return io.ErrUnexpectedEOF
7406                                 }
7407                                 b := dAtA[iNdEx]
7408                                 iNdEx++
7409                                 stringLen |= (uint64(b) & 0x7F) << shift
7410                                 if b < 0x80 {
7411                                         break
7412                                 }
7413                         }
7414                         intStringLen := int(stringLen)
7415                         if intStringLen < 0 {
7416                                 return ErrInvalidLengthGenerated
7417                         }
7418                         postIndex := iNdEx + intStringLen
7419                         if postIndex > l {
7420                                 return io.ErrUnexpectedEOF
7421                         }
7422                         m.Name = string(dAtA[iNdEx:postIndex])
7423                         iNdEx = postIndex
7424                 case 2:
7425                         if wireType != 2 {
7426                                 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
7427                         }
7428                         var stringLen uint64
7429                         for shift := uint(0); ; shift += 7 {
7430                                 if shift >= 64 {
7431                                         return ErrIntOverflowGenerated
7432                                 }
7433                                 if iNdEx >= l {
7434                                         return io.ErrUnexpectedEOF
7435                                 }
7436                                 b := dAtA[iNdEx]
7437                                 iNdEx++
7438                                 stringLen |= (uint64(b) & 0x7F) << shift
7439                                 if b < 0x80 {
7440                                         break
7441                                 }
7442                         }
7443                         intStringLen := int(stringLen)
7444                         if intStringLen < 0 {
7445                                 return ErrInvalidLengthGenerated
7446                         }
7447                         postIndex := iNdEx + intStringLen
7448                         if postIndex > l {
7449                                 return io.ErrUnexpectedEOF
7450                         }
7451                         m.Group = string(dAtA[iNdEx:postIndex])
7452                         iNdEx = postIndex
7453                 case 3:
7454                         if wireType != 2 {
7455                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
7456                         }
7457                         var stringLen uint64
7458                         for shift := uint(0); ; shift += 7 {
7459                                 if shift >= 64 {
7460                                         return ErrIntOverflowGenerated
7461                                 }
7462                                 if iNdEx >= l {
7463                                         return io.ErrUnexpectedEOF
7464                                 }
7465                                 b := dAtA[iNdEx]
7466                                 iNdEx++
7467                                 stringLen |= (uint64(b) & 0x7F) << shift
7468                                 if b < 0x80 {
7469                                         break
7470                                 }
7471                         }
7472                         intStringLen := int(stringLen)
7473                         if intStringLen < 0 {
7474                                 return ErrInvalidLengthGenerated
7475                         }
7476                         postIndex := iNdEx + intStringLen
7477                         if postIndex > l {
7478                                 return io.ErrUnexpectedEOF
7479                         }
7480                         m.Kind = string(dAtA[iNdEx:postIndex])
7481                         iNdEx = postIndex
7482                 case 4:
7483                         if wireType != 2 {
7484                                 return fmt.Errorf("proto: wrong wireType = %d for field Causes", wireType)
7485                         }
7486                         var msglen int
7487                         for shift := uint(0); ; shift += 7 {
7488                                 if shift >= 64 {
7489                                         return ErrIntOverflowGenerated
7490                                 }
7491                                 if iNdEx >= l {
7492                                         return io.ErrUnexpectedEOF
7493                                 }
7494                                 b := dAtA[iNdEx]
7495                                 iNdEx++
7496                                 msglen |= (int(b) & 0x7F) << shift
7497                                 if b < 0x80 {
7498                                         break
7499                                 }
7500                         }
7501                         if msglen < 0 {
7502                                 return ErrInvalidLengthGenerated
7503                         }
7504                         postIndex := iNdEx + msglen
7505                         if postIndex > l {
7506                                 return io.ErrUnexpectedEOF
7507                         }
7508                         m.Causes = append(m.Causes, StatusCause{})
7509                         if err := m.Causes[len(m.Causes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7510                                 return err
7511                         }
7512                         iNdEx = postIndex
7513                 case 5:
7514                         if wireType != 0 {
7515                                 return fmt.Errorf("proto: wrong wireType = %d for field RetryAfterSeconds", wireType)
7516                         }
7517                         m.RetryAfterSeconds = 0
7518                         for shift := uint(0); ; shift += 7 {
7519                                 if shift >= 64 {
7520                                         return ErrIntOverflowGenerated
7521                                 }
7522                                 if iNdEx >= l {
7523                                         return io.ErrUnexpectedEOF
7524                                 }
7525                                 b := dAtA[iNdEx]
7526                                 iNdEx++
7527                                 m.RetryAfterSeconds |= (int32(b) & 0x7F) << shift
7528                                 if b < 0x80 {
7529                                         break
7530                                 }
7531                         }
7532                 case 6:
7533                         if wireType != 2 {
7534                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
7535                         }
7536                         var stringLen uint64
7537                         for shift := uint(0); ; shift += 7 {
7538                                 if shift >= 64 {
7539                                         return ErrIntOverflowGenerated
7540                                 }
7541                                 if iNdEx >= l {
7542                                         return io.ErrUnexpectedEOF
7543                                 }
7544                                 b := dAtA[iNdEx]
7545                                 iNdEx++
7546                                 stringLen |= (uint64(b) & 0x7F) << shift
7547                                 if b < 0x80 {
7548                                         break
7549                                 }
7550                         }
7551                         intStringLen := int(stringLen)
7552                         if intStringLen < 0 {
7553                                 return ErrInvalidLengthGenerated
7554                         }
7555                         postIndex := iNdEx + intStringLen
7556                         if postIndex > l {
7557                                 return io.ErrUnexpectedEOF
7558                         }
7559                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
7560                         iNdEx = postIndex
7561                 default:
7562                         iNdEx = preIndex
7563                         skippy, err := skipGenerated(dAtA[iNdEx:])
7564                         if err != nil {
7565                                 return err
7566                         }
7567                         if skippy < 0 {
7568                                 return ErrInvalidLengthGenerated
7569                         }
7570                         if (iNdEx + skippy) > l {
7571                                 return io.ErrUnexpectedEOF
7572                         }
7573                         iNdEx += skippy
7574                 }
7575         }
7576
7577         if iNdEx > l {
7578                 return io.ErrUnexpectedEOF
7579         }
7580         return nil
7581 }
7582 func (m *Timestamp) Unmarshal(dAtA []byte) error {
7583         l := len(dAtA)
7584         iNdEx := 0
7585         for iNdEx < l {
7586                 preIndex := iNdEx
7587                 var wire uint64
7588                 for shift := uint(0); ; shift += 7 {
7589                         if shift >= 64 {
7590                                 return ErrIntOverflowGenerated
7591                         }
7592                         if iNdEx >= l {
7593                                 return io.ErrUnexpectedEOF
7594                         }
7595                         b := dAtA[iNdEx]
7596                         iNdEx++
7597                         wire |= (uint64(b) & 0x7F) << shift
7598                         if b < 0x80 {
7599                                 break
7600                         }
7601                 }
7602                 fieldNum := int32(wire >> 3)
7603                 wireType := int(wire & 0x7)
7604                 if wireType == 4 {
7605                         return fmt.Errorf("proto: Timestamp: wiretype end group for non-group")
7606                 }
7607                 if fieldNum <= 0 {
7608                         return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire)
7609                 }
7610                 switch fieldNum {
7611                 case 1:
7612                         if wireType != 0 {
7613                                 return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType)
7614                         }
7615                         m.Seconds = 0
7616                         for shift := uint(0); ; shift += 7 {
7617                                 if shift >= 64 {
7618                                         return ErrIntOverflowGenerated
7619                                 }
7620                                 if iNdEx >= l {
7621                                         return io.ErrUnexpectedEOF
7622                                 }
7623                                 b := dAtA[iNdEx]
7624                                 iNdEx++
7625                                 m.Seconds |= (int64(b) & 0x7F) << shift
7626                                 if b < 0x80 {
7627                                         break
7628                                 }
7629                         }
7630                 case 2:
7631                         if wireType != 0 {
7632                                 return fmt.Errorf("proto: wrong wireType = %d for field Nanos", wireType)
7633                         }
7634                         m.Nanos = 0
7635                         for shift := uint(0); ; shift += 7 {
7636                                 if shift >= 64 {
7637                                         return ErrIntOverflowGenerated
7638                                 }
7639                                 if iNdEx >= l {
7640                                         return io.ErrUnexpectedEOF
7641                                 }
7642                                 b := dAtA[iNdEx]
7643                                 iNdEx++
7644                                 m.Nanos |= (int32(b) & 0x7F) << shift
7645                                 if b < 0x80 {
7646                                         break
7647                                 }
7648                         }
7649                 default:
7650                         iNdEx = preIndex
7651                         skippy, err := skipGenerated(dAtA[iNdEx:])
7652                         if err != nil {
7653                                 return err
7654                         }
7655                         if skippy < 0 {
7656                                 return ErrInvalidLengthGenerated
7657                         }
7658                         if (iNdEx + skippy) > l {
7659                                 return io.ErrUnexpectedEOF
7660                         }
7661                         iNdEx += skippy
7662                 }
7663         }
7664
7665         if iNdEx > l {
7666                 return io.ErrUnexpectedEOF
7667         }
7668         return nil
7669 }
7670 func (m *TypeMeta) Unmarshal(dAtA []byte) error {
7671         l := len(dAtA)
7672         iNdEx := 0
7673         for iNdEx < l {
7674                 preIndex := iNdEx
7675                 var wire uint64
7676                 for shift := uint(0); ; shift += 7 {
7677                         if shift >= 64 {
7678                                 return ErrIntOverflowGenerated
7679                         }
7680                         if iNdEx >= l {
7681                                 return io.ErrUnexpectedEOF
7682                         }
7683                         b := dAtA[iNdEx]
7684                         iNdEx++
7685                         wire |= (uint64(b) & 0x7F) << shift
7686                         if b < 0x80 {
7687                                 break
7688                         }
7689                 }
7690                 fieldNum := int32(wire >> 3)
7691                 wireType := int(wire & 0x7)
7692                 if wireType == 4 {
7693                         return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
7694                 }
7695                 if fieldNum <= 0 {
7696                         return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
7697                 }
7698                 switch fieldNum {
7699                 case 1:
7700                         if wireType != 2 {
7701                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
7702                         }
7703                         var stringLen uint64
7704                         for shift := uint(0); ; shift += 7 {
7705                                 if shift >= 64 {
7706                                         return ErrIntOverflowGenerated
7707                                 }
7708                                 if iNdEx >= l {
7709                                         return io.ErrUnexpectedEOF
7710                                 }
7711                                 b := dAtA[iNdEx]
7712                                 iNdEx++
7713                                 stringLen |= (uint64(b) & 0x7F) << shift
7714                                 if b < 0x80 {
7715                                         break
7716                                 }
7717                         }
7718                         intStringLen := int(stringLen)
7719                         if intStringLen < 0 {
7720                                 return ErrInvalidLengthGenerated
7721                         }
7722                         postIndex := iNdEx + intStringLen
7723                         if postIndex > l {
7724                                 return io.ErrUnexpectedEOF
7725                         }
7726                         m.Kind = string(dAtA[iNdEx:postIndex])
7727                         iNdEx = postIndex
7728                 case 2:
7729                         if wireType != 2 {
7730                                 return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
7731                         }
7732                         var stringLen uint64
7733                         for shift := uint(0); ; shift += 7 {
7734                                 if shift >= 64 {
7735                                         return ErrIntOverflowGenerated
7736                                 }
7737                                 if iNdEx >= l {
7738                                         return io.ErrUnexpectedEOF
7739                                 }
7740                                 b := dAtA[iNdEx]
7741                                 iNdEx++
7742                                 stringLen |= (uint64(b) & 0x7F) << shift
7743                                 if b < 0x80 {
7744                                         break
7745                                 }
7746                         }
7747                         intStringLen := int(stringLen)
7748                         if intStringLen < 0 {
7749                                 return ErrInvalidLengthGenerated
7750                         }
7751                         postIndex := iNdEx + intStringLen
7752                         if postIndex > l {
7753                                 return io.ErrUnexpectedEOF
7754                         }
7755                         m.APIVersion = string(dAtA[iNdEx:postIndex])
7756                         iNdEx = postIndex
7757                 default:
7758                         iNdEx = preIndex
7759                         skippy, err := skipGenerated(dAtA[iNdEx:])
7760                         if err != nil {
7761                                 return err
7762                         }
7763                         if skippy < 0 {
7764                                 return ErrInvalidLengthGenerated
7765                         }
7766                         if (iNdEx + skippy) > l {
7767                                 return io.ErrUnexpectedEOF
7768                         }
7769                         iNdEx += skippy
7770                 }
7771         }
7772
7773         if iNdEx > l {
7774                 return io.ErrUnexpectedEOF
7775         }
7776         return nil
7777 }
7778 func (m *UpdateOptions) Unmarshal(dAtA []byte) error {
7779         l := len(dAtA)
7780         iNdEx := 0
7781         for iNdEx < l {
7782                 preIndex := iNdEx
7783                 var wire uint64
7784                 for shift := uint(0); ; shift += 7 {
7785                         if shift >= 64 {
7786                                 return ErrIntOverflowGenerated
7787                         }
7788                         if iNdEx >= l {
7789                                 return io.ErrUnexpectedEOF
7790                         }
7791                         b := dAtA[iNdEx]
7792                         iNdEx++
7793                         wire |= (uint64(b) & 0x7F) << shift
7794                         if b < 0x80 {
7795                                 break
7796                         }
7797                 }
7798                 fieldNum := int32(wire >> 3)
7799                 wireType := int(wire & 0x7)
7800                 if wireType == 4 {
7801                         return fmt.Errorf("proto: UpdateOptions: wiretype end group for non-group")
7802                 }
7803                 if fieldNum <= 0 {
7804                         return fmt.Errorf("proto: UpdateOptions: illegal tag %d (wire type %d)", fieldNum, wire)
7805                 }
7806                 switch fieldNum {
7807                 case 1:
7808                         if wireType != 2 {
7809                                 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
7810                         }
7811                         var stringLen uint64
7812                         for shift := uint(0); ; shift += 7 {
7813                                 if shift >= 64 {
7814                                         return ErrIntOverflowGenerated
7815                                 }
7816                                 if iNdEx >= l {
7817                                         return io.ErrUnexpectedEOF
7818                                 }
7819                                 b := dAtA[iNdEx]
7820                                 iNdEx++
7821                                 stringLen |= (uint64(b) & 0x7F) << shift
7822                                 if b < 0x80 {
7823                                         break
7824                                 }
7825                         }
7826                         intStringLen := int(stringLen)
7827                         if intStringLen < 0 {
7828                                 return ErrInvalidLengthGenerated
7829                         }
7830                         postIndex := iNdEx + intStringLen
7831                         if postIndex > l {
7832                                 return io.ErrUnexpectedEOF
7833                         }
7834                         m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
7835                         iNdEx = postIndex
7836                 default:
7837                         iNdEx = preIndex
7838                         skippy, err := skipGenerated(dAtA[iNdEx:])
7839                         if err != nil {
7840                                 return err
7841                         }
7842                         if skippy < 0 {
7843                                 return ErrInvalidLengthGenerated
7844                         }
7845                         if (iNdEx + skippy) > l {
7846                                 return io.ErrUnexpectedEOF
7847                         }
7848                         iNdEx += skippy
7849                 }
7850         }
7851
7852         if iNdEx > l {
7853                 return io.ErrUnexpectedEOF
7854         }
7855         return nil
7856 }
7857 func (m *Verbs) Unmarshal(dAtA []byte) error {
7858         l := len(dAtA)
7859         iNdEx := 0
7860         for iNdEx < l {
7861                 preIndex := iNdEx
7862                 var wire uint64
7863                 for shift := uint(0); ; shift += 7 {
7864                         if shift >= 64 {
7865                                 return ErrIntOverflowGenerated
7866                         }
7867                         if iNdEx >= l {
7868                                 return io.ErrUnexpectedEOF
7869                         }
7870                         b := dAtA[iNdEx]
7871                         iNdEx++
7872                         wire |= (uint64(b) & 0x7F) << shift
7873                         if b < 0x80 {
7874                                 break
7875                         }
7876                 }
7877                 fieldNum := int32(wire >> 3)
7878                 wireType := int(wire & 0x7)
7879                 if wireType == 4 {
7880                         return fmt.Errorf("proto: Verbs: wiretype end group for non-group")
7881                 }
7882                 if fieldNum <= 0 {
7883                         return fmt.Errorf("proto: Verbs: illegal tag %d (wire type %d)", fieldNum, wire)
7884                 }
7885                 switch fieldNum {
7886                 case 1:
7887                         if wireType != 2 {
7888                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7889                         }
7890                         var stringLen uint64
7891                         for shift := uint(0); ; shift += 7 {
7892                                 if shift >= 64 {
7893                                         return ErrIntOverflowGenerated
7894                                 }
7895                                 if iNdEx >= l {
7896                                         return io.ErrUnexpectedEOF
7897                                 }
7898                                 b := dAtA[iNdEx]
7899                                 iNdEx++
7900                                 stringLen |= (uint64(b) & 0x7F) << shift
7901                                 if b < 0x80 {
7902                                         break
7903                                 }
7904                         }
7905                         intStringLen := int(stringLen)
7906                         if intStringLen < 0 {
7907                                 return ErrInvalidLengthGenerated
7908                         }
7909                         postIndex := iNdEx + intStringLen
7910                         if postIndex > l {
7911                                 return io.ErrUnexpectedEOF
7912                         }
7913                         *m = append(*m, string(dAtA[iNdEx:postIndex]))
7914                         iNdEx = postIndex
7915                 default:
7916                         iNdEx = preIndex
7917                         skippy, err := skipGenerated(dAtA[iNdEx:])
7918                         if err != nil {
7919                                 return err
7920                         }
7921                         if skippy < 0 {
7922                                 return ErrInvalidLengthGenerated
7923                         }
7924                         if (iNdEx + skippy) > l {
7925                                 return io.ErrUnexpectedEOF
7926                         }
7927                         iNdEx += skippy
7928                 }
7929         }
7930
7931         if iNdEx > l {
7932                 return io.ErrUnexpectedEOF
7933         }
7934         return nil
7935 }
7936 func (m *WatchEvent) Unmarshal(dAtA []byte) error {
7937         l := len(dAtA)
7938         iNdEx := 0
7939         for iNdEx < l {
7940                 preIndex := iNdEx
7941                 var wire uint64
7942                 for shift := uint(0); ; shift += 7 {
7943                         if shift >= 64 {
7944                                 return ErrIntOverflowGenerated
7945                         }
7946                         if iNdEx >= l {
7947                                 return io.ErrUnexpectedEOF
7948                         }
7949                         b := dAtA[iNdEx]
7950                         iNdEx++
7951                         wire |= (uint64(b) & 0x7F) << shift
7952                         if b < 0x80 {
7953                                 break
7954                         }
7955                 }
7956                 fieldNum := int32(wire >> 3)
7957                 wireType := int(wire & 0x7)
7958                 if wireType == 4 {
7959                         return fmt.Errorf("proto: WatchEvent: wiretype end group for non-group")
7960                 }
7961                 if fieldNum <= 0 {
7962                         return fmt.Errorf("proto: WatchEvent: illegal tag %d (wire type %d)", fieldNum, wire)
7963                 }
7964                 switch fieldNum {
7965                 case 1:
7966                         if wireType != 2 {
7967                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7968                         }
7969                         var stringLen uint64
7970                         for shift := uint(0); ; shift += 7 {
7971                                 if shift >= 64 {
7972                                         return ErrIntOverflowGenerated
7973                                 }
7974                                 if iNdEx >= l {
7975                                         return io.ErrUnexpectedEOF
7976                                 }
7977                                 b := dAtA[iNdEx]
7978                                 iNdEx++
7979                                 stringLen |= (uint64(b) & 0x7F) << shift
7980                                 if b < 0x80 {
7981                                         break
7982                                 }
7983                         }
7984                         intStringLen := int(stringLen)
7985                         if intStringLen < 0 {
7986                                 return ErrInvalidLengthGenerated
7987                         }
7988                         postIndex := iNdEx + intStringLen
7989                         if postIndex > l {
7990                                 return io.ErrUnexpectedEOF
7991                         }
7992                         m.Type = string(dAtA[iNdEx:postIndex])
7993                         iNdEx = postIndex
7994                 case 2:
7995                         if wireType != 2 {
7996                                 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
7997                         }
7998                         var msglen int
7999                         for shift := uint(0); ; shift += 7 {
8000                                 if shift >= 64 {
8001                                         return ErrIntOverflowGenerated
8002                                 }
8003                                 if iNdEx >= l {
8004                                         return io.ErrUnexpectedEOF
8005                                 }
8006                                 b := dAtA[iNdEx]
8007                                 iNdEx++
8008                                 msglen |= (int(b) & 0x7F) << shift
8009                                 if b < 0x80 {
8010                                         break
8011                                 }
8012                         }
8013                         if msglen < 0 {
8014                                 return ErrInvalidLengthGenerated
8015                         }
8016                         postIndex := iNdEx + msglen
8017                         if postIndex > l {
8018                                 return io.ErrUnexpectedEOF
8019                         }
8020                         if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8021                                 return err
8022                         }
8023                         iNdEx = postIndex
8024                 default:
8025                         iNdEx = preIndex
8026                         skippy, err := skipGenerated(dAtA[iNdEx:])
8027                         if err != nil {
8028                                 return err
8029                         }
8030                         if skippy < 0 {
8031                                 return ErrInvalidLengthGenerated
8032                         }
8033                         if (iNdEx + skippy) > l {
8034                                 return io.ErrUnexpectedEOF
8035                         }
8036                         iNdEx += skippy
8037                 }
8038         }
8039
8040         if iNdEx > l {
8041                 return io.ErrUnexpectedEOF
8042         }
8043         return nil
8044 }
8045 func skipGenerated(dAtA []byte) (n int, err error) {
8046         l := len(dAtA)
8047         iNdEx := 0
8048         for iNdEx < l {
8049                 var wire uint64
8050                 for shift := uint(0); ; shift += 7 {
8051                         if shift >= 64 {
8052                                 return 0, ErrIntOverflowGenerated
8053                         }
8054                         if iNdEx >= l {
8055                                 return 0, io.ErrUnexpectedEOF
8056                         }
8057                         b := dAtA[iNdEx]
8058                         iNdEx++
8059                         wire |= (uint64(b) & 0x7F) << shift
8060                         if b < 0x80 {
8061                                 break
8062                         }
8063                 }
8064                 wireType := int(wire & 0x7)
8065                 switch wireType {
8066                 case 0:
8067                         for shift := uint(0); ; shift += 7 {
8068                                 if shift >= 64 {
8069                                         return 0, ErrIntOverflowGenerated
8070                                 }
8071                                 if iNdEx >= l {
8072                                         return 0, io.ErrUnexpectedEOF
8073                                 }
8074                                 iNdEx++
8075                                 if dAtA[iNdEx-1] < 0x80 {
8076                                         break
8077                                 }
8078                         }
8079                         return iNdEx, nil
8080                 case 1:
8081                         iNdEx += 8
8082                         return iNdEx, nil
8083                 case 2:
8084                         var length int
8085                         for shift := uint(0); ; shift += 7 {
8086                                 if shift >= 64 {
8087                                         return 0, ErrIntOverflowGenerated
8088                                 }
8089                                 if iNdEx >= l {
8090                                         return 0, io.ErrUnexpectedEOF
8091                                 }
8092                                 b := dAtA[iNdEx]
8093                                 iNdEx++
8094                                 length |= (int(b) & 0x7F) << shift
8095                                 if b < 0x80 {
8096                                         break
8097                                 }
8098                         }
8099                         iNdEx += length
8100                         if length < 0 {
8101                                 return 0, ErrInvalidLengthGenerated
8102                         }
8103                         return iNdEx, nil
8104                 case 3:
8105                         for {
8106                                 var innerWire uint64
8107                                 var start int = iNdEx
8108                                 for shift := uint(0); ; shift += 7 {
8109                                         if shift >= 64 {
8110                                                 return 0, ErrIntOverflowGenerated
8111                                         }
8112                                         if iNdEx >= l {
8113                                                 return 0, io.ErrUnexpectedEOF
8114                                         }
8115                                         b := dAtA[iNdEx]
8116                                         iNdEx++
8117                                         innerWire |= (uint64(b) & 0x7F) << shift
8118                                         if b < 0x80 {
8119                                                 break
8120                                         }
8121                                 }
8122                                 innerWireType := int(innerWire & 0x7)
8123                                 if innerWireType == 4 {
8124                                         break
8125                                 }
8126                                 next, err := skipGenerated(dAtA[start:])
8127                                 if err != nil {
8128                                         return 0, err
8129                                 }
8130                                 iNdEx = start + next
8131                         }
8132                         return iNdEx, nil
8133                 case 4:
8134                         return iNdEx, nil
8135                 case 5:
8136                         iNdEx += 4
8137                         return iNdEx, nil
8138                 default:
8139                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
8140                 }
8141         }
8142         panic("unreachable")
8143 }
8144
8145 var (
8146         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
8147         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
8148 )
8149
8150 func init() {
8151         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto", fileDescriptorGenerated)
8152 }
8153
8154 var fileDescriptorGenerated = []byte{
8155         // 2465 bytes of a gzipped FileDescriptorProto
8156         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4d, 0x6c, 0x23, 0x49,
8157         0xf5, 0x4f, 0xdb, 0xb1, 0x63, 0x3f, 0xc7, 0xf9, 0xa8, 0xcd, 0xfe, 0xff, 0xde, 0x08, 0xec, 0x6c,
8158         0x2f, 0x5a, 0x65, 0x61, 0xd6, 0x26, 0x59, 0x58, 0x0d, 0x03, 0x2c, 0xc4, 0x71, 0x66, 0x14, 0xed,
8159         0x64, 0xc6, 0xaa, 0xec, 0x0c, 0x62, 0x18, 0x21, 0x3a, 0xdd, 0x15, 0xa7, 0x49, 0xbb, 0xdb, 0x5b,
8160         0xd5, 0xce, 0x8c, 0xe1, 0xc0, 0x1e, 0x40, 0x70, 0x40, 0x68, 0x8e, 0x9c, 0xd0, 0x8e, 0xe0, 0xc2,
8161         0x95, 0x13, 0x17, 0x38, 0x21, 0x31, 0xc7, 0x91, 0xb8, 0xec, 0x01, 0x59, 0x3b, 0xe6, 0xc0, 0x09,
8162         0x71, 0xcf, 0x09, 0x55, 0x75, 0x75, 0x75, 0xb7, 0x1d, 0x4f, 0xda, 0x3b, 0xbb, 0x88, 0x53, 0xd2,
8163         0xef, 0xe3, 0xf7, 0x5e, 0x55, 0xbd, 0x7a, 0xef, 0xd5, 0x33, 0x1c, 0x9c, 0x5e, 0x65, 0x75, 0xdb,
8164         0x6b, 0x9c, 0xf6, 0x8f, 0x08, 0x75, 0x89, 0x4f, 0x58, 0xe3, 0x8c, 0xb8, 0x96, 0x47, 0x1b, 0x92,
8165         0x61, 0xf4, 0xec, 0xae, 0x61, 0x9e, 0xd8, 0x2e, 0xa1, 0x83, 0x46, 0xef, 0xb4, 0xc3, 0x09, 0xac,
8166         0xd1, 0x25, 0xbe, 0xd1, 0x38, 0xdb, 0x6a, 0x74, 0x88, 0x4b, 0xa8, 0xe1, 0x13, 0xab, 0xde, 0xa3,
8167         0x9e, 0xef, 0xa1, 0x2f, 0x04, 0x5a, 0xf5, 0xb8, 0x56, 0xbd, 0x77, 0xda, 0xe1, 0x04, 0x56, 0xe7,
8168         0x5a, 0xf5, 0xb3, 0xad, 0xf5, 0x37, 0x3b, 0xb6, 0x7f, 0xd2, 0x3f, 0xaa, 0x9b, 0x5e, 0xb7, 0xd1,
8169         0xf1, 0x3a, 0x5e, 0x43, 0x28, 0x1f, 0xf5, 0x8f, 0xc5, 0x97, 0xf8, 0x10, 0xff, 0x05, 0xa0, 0xeb,
8170         0x53, 0x5d, 0xa1, 0x7d, 0xd7, 0xb7, 0xbb, 0x64, 0xdc, 0x8b, 0xf5, 0xb7, 0x2f, 0x53, 0x60, 0xe6,
8171         0x09, 0xe9, 0x1a, 0xe3, 0x7a, 0xfa, 0x5f, 0xb3, 0x50, 0xd8, 0x69, 0xef, 0xdf, 0xa0, 0x5e, 0xbf,
8172         0x87, 0x36, 0x60, 0xde, 0x35, 0xba, 0xa4, 0xa2, 0x6d, 0x68, 0x9b, 0xc5, 0xe6, 0xe2, 0x93, 0x61,
8173         0x6d, 0x6e, 0x34, 0xac, 0xcd, 0xdf, 0x32, 0xba, 0x04, 0x0b, 0x0e, 0x72, 0xa0, 0x70, 0x46, 0x28,
8174         0xb3, 0x3d, 0x97, 0x55, 0x32, 0x1b, 0xd9, 0xcd, 0xd2, 0xf6, 0x3b, 0xf5, 0x34, 0xeb, 0xaf, 0x0b,
8175         0x03, 0x77, 0x03, 0xd5, 0xeb, 0x1e, 0x6d, 0xd9, 0xcc, 0xf4, 0xce, 0x08, 0x1d, 0x34, 0x57, 0xa4,
8176         0x95, 0x82, 0x64, 0x32, 0xac, 0x2c, 0xa0, 0x9f, 0x6a, 0xb0, 0xd2, 0xa3, 0xe4, 0x98, 0x50, 0x4a,
8177         0x2c, 0xc9, 0xaf, 0x64, 0x37, 0xb4, 0x4f, 0xc1, 0x6c, 0x45, 0x9a, 0x5d, 0x69, 0x8f, 0xe1, 0xe3,
8178         0x09, 0x8b, 0xe8, 0xb7, 0x1a, 0xac, 0x33, 0x42, 0xcf, 0x08, 0xdd, 0xb1, 0x2c, 0x4a, 0x18, 0x6b,
8179         0x0e, 0x76, 0x1d, 0x9b, 0xb8, 0xfe, 0xee, 0x7e, 0x0b, 0xb3, 0xca, 0xbc, 0xd8, 0x87, 0x6f, 0xa5,
8180         0x73, 0xe8, 0x70, 0x1a, 0x4e, 0x53, 0x97, 0x1e, 0xad, 0x4f, 0x15, 0x61, 0xf8, 0x39, 0x6e, 0xe8,
8181         0xc7, 0xb0, 0x18, 0x1e, 0xe4, 0x4d, 0x9b, 0xf9, 0xe8, 0x2e, 0xe4, 0x3b, 0xfc, 0x83, 0x55, 0x34,
8182         0xe1, 0x60, 0x3d, 0x9d, 0x83, 0x21, 0x46, 0x73, 0x49, 0xfa, 0x93, 0x17, 0x9f, 0x0c, 0x4b, 0x34,
8183         0xfd, 0x4f, 0x59, 0x28, 0xed, 0xb4, 0xf7, 0x31, 0x61, 0x5e, 0x9f, 0x9a, 0x24, 0x45, 0xd0, 0x6c,
8184         0x03, 0xf0, 0xbf, 0xac, 0x67, 0x98, 0xc4, 0xaa, 0x64, 0x36, 0xb4, 0xcd, 0x42, 0x13, 0x49, 0x39,
8185         0xb8, 0xa5, 0x38, 0x38, 0x26, 0xc5, 0x51, 0x4f, 0x6d, 0xd7, 0x12, 0xa7, 0x1d, 0x43, 0x7d, 0xd7,
8186         0x76, 0x2d, 0x2c, 0x38, 0xe8, 0x26, 0xe4, 0xce, 0x08, 0x3d, 0xe2, 0xfb, 0xcf, 0x03, 0xe2, 0x4b,
8187         0xe9, 0x96, 0x77, 0x97, 0xab, 0x34, 0x8b, 0xa3, 0x61, 0x2d, 0x27, 0xfe, 0xc5, 0x01, 0x08, 0xaa,
8188         0x03, 0xb0, 0x13, 0x8f, 0xfa, 0xc2, 0x9d, 0x4a, 0x6e, 0x23, 0xbb, 0x59, 0x6c, 0x2e, 0x71, 0xff,
8189         0x0e, 0x15, 0x15, 0xc7, 0x24, 0xd0, 0x55, 0x58, 0x64, 0xb6, 0xdb, 0xe9, 0x3b, 0x06, 0xe5, 0x84,
8190         0x4a, 0x5e, 0xf8, 0xb9, 0x26, 0xfd, 0x5c, 0x3c, 0x8c, 0xf1, 0x70, 0x42, 0x92, 0x5b, 0x32, 0x0d,
8191         0x9f, 0x74, 0x3c, 0x6a, 0x13, 0x56, 0x59, 0x88, 0x2c, 0xed, 0x2a, 0x2a, 0x8e, 0x49, 0xa0, 0xd7,
8192         0x20, 0x27, 0x76, 0xbe, 0x52, 0x10, 0x26, 0xca, 0xd2, 0x44, 0x4e, 0x1c, 0x0b, 0x0e, 0x78, 0xe8,
8193         0x0d, 0x58, 0x90, 0xb7, 0xa6, 0x52, 0x14, 0x62, 0xcb, 0x52, 0x6c, 0x21, 0x0c, 0xeb, 0x90, 0xaf,
8194         0xff, 0x41, 0x83, 0xe5, 0xd8, 0xf9, 0x89, 0x58, 0xb9, 0x0a, 0x8b, 0x9d, 0xd8, 0x4d, 0x91, 0x67,
8195         0xa9, 0x56, 0x13, 0xbf, 0x45, 0x38, 0x21, 0x89, 0x08, 0x14, 0xa9, 0x44, 0x0a, 0x33, 0xc2, 0x56,
8196         0xea, 0x40, 0x0b, 0x7d, 0x88, 0x2c, 0xc5, 0x88, 0x0c, 0x47, 0xc8, 0xfa, 0x3f, 0x35, 0x11, 0x74,
8197         0x61, 0x8e, 0x40, 0x9b, 0xb1, 0x3c, 0xa4, 0x89, 0x2d, 0x5c, 0x9c, 0x92, 0x43, 0x2e, 0xb9, 0xbc,
8198         0x99, 0xff, 0x89, 0xcb, 0x7b, 0xad, 0xf0, 0xeb, 0x0f, 0x6b, 0x73, 0x1f, 0xfc, 0x7d, 0x63, 0x4e,
8199         0xff, 0x99, 0x06, 0xe5, 0x5d, 0x4a, 0x0c, 0x9f, 0xdc, 0xee, 0xf9, 0x62, 0x05, 0x3a, 0xe4, 0x2d,
8200         0x3a, 0xc0, 0x7d, 0x57, 0xae, 0x14, 0xf8, 0xa5, 0x6c, 0x09, 0x0a, 0x96, 0x1c, 0xd4, 0x86, 0x35,
8201         0xdb, 0x35, 0x9d, 0xbe, 0x45, 0xee, 0xb8, 0xb6, 0x6b, 0xfb, 0xb6, 0xe1, 0xd8, 0x3f, 0x52, 0x97,
8202         0xed, 0x73, 0xd2, 0xbb, 0xb5, 0xfd, 0x0b, 0x64, 0xf0, 0x85, 0x9a, 0xfa, 0xcf, 0xb3, 0x50, 0x6e,
8203         0x11, 0x87, 0x44, 0x7e, 0x5c, 0x07, 0xd4, 0xa1, 0x86, 0x49, 0xda, 0x84, 0xda, 0x9e, 0x75, 0x48,
8204         0x4c, 0xcf, 0xb5, 0x98, 0x08, 0x95, 0x6c, 0xf3, 0xff, 0x46, 0xc3, 0x1a, 0xba, 0x31, 0xc1, 0xc5,
8205         0x17, 0x68, 0x20, 0x07, 0xca, 0x3d, 0x2a, 0xfe, 0xb7, 0x7d, 0x59, 0x48, 0xf8, 0x05, 0x7e, 0x2b,
8206         0xdd, 0x19, 0xb4, 0xe3, 0xaa, 0xcd, 0xd5, 0xd1, 0xb0, 0x56, 0x4e, 0x90, 0x70, 0x12, 0x1c, 0x7d,
8207         0x1b, 0x56, 0x3c, 0xda, 0x3b, 0x31, 0xdc, 0x16, 0xe9, 0x11, 0xd7, 0x22, 0xae, 0xcf, 0x44, 0x52,
8208         0x29, 0x34, 0xd7, 0x78, 0xfa, 0xbf, 0x3d, 0xc6, 0xc3, 0x13, 0xd2, 0xe8, 0x1e, 0xac, 0xf6, 0xa8,
8209         0xd7, 0x33, 0x3a, 0x06, 0x47, 0x6c, 0x7b, 0x8e, 0x6d, 0x0e, 0x44, 0xd2, 0x29, 0x36, 0xaf, 0x8c,
8210         0x86, 0xb5, 0xd5, 0xf6, 0x38, 0xf3, 0x7c, 0x58, 0x7b, 0x49, 0x6c, 0x1d, 0xa7, 0x44, 0x4c, 0x3c,
8211         0x09, 0x13, 0x3b, 0xdb, 0xdc, 0xb4, 0xb3, 0xd5, 0xf7, 0xa1, 0xd0, 0xea, 0x53, 0xa1, 0x85, 0xbe,
8212         0x09, 0x05, 0x4b, 0xfe, 0x2f, 0x77, 0xfe, 0xd5, 0xb0, 0x7e, 0x86, 0x32, 0xe7, 0xc3, 0x5a, 0x99,
8213         0x57, 0xfc, 0x7a, 0x48, 0xc0, 0x4a, 0x45, 0xbf, 0x0f, 0xe5, 0xbd, 0x87, 0x3d, 0x8f, 0xfa, 0xe1,
8214         0x99, 0xbe, 0x0e, 0x79, 0x22, 0x08, 0x02, 0xad, 0x10, 0x25, 0xfd, 0x40, 0x0c, 0x4b, 0x2e, 0x4f,
8215         0x42, 0xe4, 0xa1, 0x61, 0xfa, 0x32, 0xa0, 0x54, 0x12, 0xda, 0xe3, 0x44, 0x1c, 0xf0, 0xf4, 0xc7,
8216         0x1a, 0xc0, 0x0d, 0xa2, 0xb0, 0x77, 0x60, 0x39, 0xbc, 0xc0, 0xc9, 0xbc, 0xf2, 0xff, 0x52, 0x7b,
8217         0x19, 0x27, 0xd9, 0x78, 0x5c, 0xfe, 0x33, 0x08, 0xeb, 0xfb, 0x50, 0x14, 0xd9, 0x8c, 0x17, 0x92,
8218         0x28, 0xb5, 0x6a, 0xcf, 0x49, 0xad, 0x61, 0x25, 0xca, 0x4c, 0xab, 0x44, 0xb1, 0xcb, 0xeb, 0x40,
8219         0x39, 0xd0, 0x0d, 0x8b, 0x63, 0x2a, 0x0b, 0x57, 0xa0, 0x10, 0x2e, 0x5c, 0x5a, 0x51, 0x4d, 0x51,
8220         0x08, 0x84, 0x95, 0x44, 0xcc, 0xda, 0x09, 0x24, 0x32, 0x73, 0x3a, 0x63, 0xb1, 0x4a, 0x91, 0x79,
8221         0x7e, 0xa5, 0x88, 0x59, 0xfa, 0x09, 0x54, 0xa6, 0x75, 0x52, 0x2f, 0x50, 0x3b, 0xd2, 0xbb, 0xa2,
8222         0xff, 0x4a, 0x83, 0x95, 0x38, 0x52, 0xfa, 0xe3, 0x4b, 0x6f, 0xe4, 0xf2, 0x9e, 0x23, 0xb6, 0x23,
8223         0xbf, 0xd1, 0x60, 0x2d, 0xb1, 0xb4, 0x99, 0x4e, 0x7c, 0x06, 0xa7, 0xe2, 0xc1, 0x91, 0x9d, 0x21,
8224         0x38, 0x1a, 0x50, 0xda, 0x57, 0x71, 0x4f, 0x2f, 0xef, 0xd2, 0xf4, 0x3f, 0x6b, 0xb0, 0x18, 0xd3,
8225         0x60, 0xe8, 0x3e, 0x2c, 0xf0, 0x1c, 0x68, 0xbb, 0x1d, 0xd9, 0x41, 0xa6, 0x2c, 0xec, 0x31, 0x90,
8226         0x68, 0x5d, 0xed, 0x00, 0x09, 0x87, 0x90, 0xa8, 0x0d, 0x79, 0x4a, 0x58, 0xdf, 0xf1, 0x65, 0xfa,
8227         0xbf, 0x92, 0xb2, 0x04, 0xfb, 0x86, 0xdf, 0x67, 0x41, 0x9e, 0xc4, 0x42, 0x1f, 0x4b, 0x1c, 0xfd,
8228         0x6f, 0x19, 0x28, 0xdf, 0x34, 0x8e, 0x88, 0x73, 0x48, 0x1c, 0x62, 0xfa, 0x1e, 0x45, 0x3f, 0x86,
8229         0x52, 0xd7, 0xf0, 0xcd, 0x13, 0x41, 0x0d, 0xfb, 0xe0, 0x56, 0x3a, 0x43, 0x09, 0xa4, 0xfa, 0x41,
8230         0x04, 0xb3, 0xe7, 0xfa, 0x74, 0xd0, 0x7c, 0x49, 0x2e, 0xac, 0x14, 0xe3, 0xe0, 0xb8, 0x35, 0xf1,
8231         0x78, 0x11, 0xdf, 0x7b, 0x0f, 0x7b, 0xbc, 0xe0, 0xcf, 0xfe, 0x66, 0x4a, 0xb8, 0x80, 0xc9, 0xfb,
8232         0x7d, 0x9b, 0x92, 0x2e, 0x71, 0xfd, 0xe8, 0xf1, 0x72, 0x30, 0x86, 0x8f, 0x27, 0x2c, 0xae, 0xbf,
8233         0x03, 0x2b, 0xe3, 0xce, 0xa3, 0x15, 0xc8, 0x9e, 0x92, 0x41, 0x10, 0x0b, 0x98, 0xff, 0x8b, 0xd6,
8234         0x20, 0x77, 0x66, 0x38, 0x7d, 0x99, 0x7f, 0x70, 0xf0, 0x71, 0x2d, 0x73, 0x55, 0xd3, 0x7f, 0xa7,
8235         0x41, 0x65, 0x9a, 0x23, 0xe8, 0xf3, 0x31, 0xa0, 0x66, 0x49, 0x7a, 0x95, 0x7d, 0x97, 0x0c, 0x02,
8236         0xd4, 0x3d, 0x28, 0x78, 0x3d, 0xfe, 0xdc, 0xf4, 0xa8, 0x8c, 0xf3, 0x37, 0xc2, 0xd8, 0xbd, 0x2d,
8237         0xe9, 0xe7, 0xc3, 0xda, 0xcb, 0x09, 0xf8, 0x90, 0x81, 0x95, 0x2a, 0x2f, 0x92, 0xc2, 0x1f, 0x5e,
8238         0xb8, 0x55, 0x91, 0xbc, 0x2b, 0x28, 0x58, 0x72, 0xf4, 0x3f, 0x6a, 0x30, 0x2f, 0x5a, 0xd9, 0xfb,
8239         0x50, 0xe0, 0xfb, 0x67, 0x19, 0xbe, 0x21, 0xfc, 0x4a, 0xfd, 0xf0, 0xe1, 0xda, 0x07, 0xc4, 0x37,
8240         0xa2, 0xfb, 0x15, 0x52, 0xb0, 0x42, 0x44, 0x18, 0x72, 0xb6, 0x4f, 0xba, 0xe1, 0x41, 0xbe, 0x39,
8241         0x15, 0x5a, 0x3e, 0xbb, 0xeb, 0xd8, 0x78, 0xb0, 0xf7, 0xd0, 0x27, 0x2e, 0x3f, 0x8c, 0x28, 0x19,
8242         0xec, 0x73, 0x0c, 0x1c, 0x40, 0xe9, 0xbf, 0xd7, 0x40, 0x99, 0xe2, 0xd7, 0x9d, 0x11, 0xe7, 0xf8,
8243         0xa6, 0xed, 0x9e, 0xca, 0x6d, 0x55, 0xee, 0x1c, 0x4a, 0x3a, 0x56, 0x12, 0x17, 0x95, 0xd8, 0xcc,
8244         0x8c, 0x25, 0xf6, 0x0a, 0x14, 0x4c, 0xcf, 0xf5, 0x6d, 0xb7, 0x3f, 0x91, 0x5f, 0x76, 0x25, 0x1d,
8245         0x2b, 0x09, 0xfd, 0x69, 0x16, 0x4a, 0xdc, 0xd7, 0xb0, 0xc6, 0x7f, 0x1d, 0xca, 0x4e, 0xfc, 0xf4,
8246         0xa4, 0xcf, 0x2f, 0x4b, 0x88, 0xe4, 0x7d, 0xc4, 0x49, 0x59, 0xae, 0x7c, 0x6c, 0x13, 0xc7, 0x52,
8247         0xca, 0x99, 0xa4, 0xf2, 0xf5, 0x38, 0x13, 0x27, 0x65, 0x79, 0x9e, 0x7d, 0xc0, 0xe3, 0x5a, 0x36,
8248         0x73, 0x6a, 0x6b, 0xbf, 0xc3, 0x89, 0x38, 0xe0, 0x5d, 0xb4, 0x3f, 0xf3, 0x33, 0xee, 0xcf, 0x35,
8249         0x58, 0xe2, 0x07, 0xe9, 0xf5, 0xfd, 0xb0, 0xe3, 0xcd, 0x89, 0xbe, 0x0b, 0x8d, 0x86, 0xb5, 0xa5,
8250         0xf7, 0x12, 0x1c, 0x3c, 0x26, 0x39, 0xb5, 0x7d, 0xc9, 0x7f, 0xd2, 0xf6, 0x85, 0xaf, 0xda, 0xb1,
8251         0xbb, 0xb6, 0x5f, 0x59, 0x10, 0x4e, 0xa8, 0x55, 0xdf, 0xe4, 0x44, 0x1c, 0xf0, 0x12, 0x47, 0x5a,
8252         0xb8, 0xf4, 0x48, 0xdf, 0x87, 0xe2, 0x81, 0x6d, 0x52, 0x8f, 0xaf, 0x85, 0x17, 0x26, 0x96, 0x68,
8253         0xec, 0x55, 0x02, 0x0f, 0xd7, 0x18, 0xf2, 0xb9, 0x2b, 0xae, 0xe1, 0x7a, 0x41, 0xfb, 0x9e, 0x8b,
8254         0x5c, 0xb9, 0xc5, 0x89, 0x38, 0xe0, 0x5d, 0x5b, 0xe3, 0xf5, 0xe8, 0x17, 0x8f, 0x6b, 0x73, 0x8f,
8255         0x1e, 0xd7, 0xe6, 0x3e, 0x7c, 0x2c, 0x6b, 0xd3, 0xbf, 0x00, 0xe0, 0xf6, 0xd1, 0x0f, 0x89, 0x19,
8256         0xc4, 0xfc, 0xe5, 0x13, 0x04, 0xde, 0x63, 0xc8, 0xc1, 0x95, 0x78, 0x6d, 0x67, 0xc6, 0x7a, 0x8c,
8257         0x18, 0x0f, 0x27, 0x24, 0x51, 0x03, 0x8a, 0x6a, 0xaa, 0x20, 0xe3, 0x7b, 0x55, 0xaa, 0x15, 0xd5,
8258         0xe8, 0x01, 0x47, 0x32, 0x89, 0x0b, 0x38, 0x7f, 0xe9, 0x05, 0x6c, 0x42, 0xb6, 0x6f, 0x5b, 0x22,
8259         0x24, 0x8a, 0xcd, 0x2f, 0x87, 0x09, 0xf0, 0xce, 0x7e, 0xeb, 0x7c, 0x58, 0x7b, 0x75, 0xda, 0x48,
8260         0xce, 0x1f, 0xf4, 0x08, 0xab, 0xdf, 0xd9, 0x6f, 0x61, 0xae, 0x7c, 0x51, 0x90, 0xe6, 0x67, 0x0c,
8261         0xd2, 0x6d, 0x00, 0xb9, 0x6a, 0xae, 0x1d, 0xc4, 0x86, 0x9a, 0xb0, 0xdc, 0x50, 0x1c, 0x1c, 0x93,
8262         0x42, 0x0c, 0x56, 0x4d, 0xfe, 0xce, 0xb4, 0x3d, 0x97, 0x1f, 0x3d, 0xf3, 0x8d, 0x6e, 0x30, 0x63,
8263         0x28, 0x6d, 0x7f, 0x31, 0x5d, 0xc6, 0xe4, 0x6a, 0xcd, 0x57, 0xa4, 0x99, 0xd5, 0xdd, 0x71, 0x30,
8264         0x3c, 0x89, 0x8f, 0x3c, 0x58, 0xb5, 0xe4, 0xcb, 0x28, 0x32, 0x5a, 0x9c, 0xd9, 0xe8, 0xcb, 0xdc,
8265         0x60, 0x6b, 0x1c, 0x08, 0x4f, 0x62, 0xa3, 0xef, 0xc3, 0x7a, 0x48, 0x9c, 0x7c, 0x9e, 0x56, 0x40,
8266         0xec, 0x54, 0x95, 0x3f, 0xdc, 0x5b, 0x53, 0xa5, 0xf0, 0x73, 0x10, 0x90, 0x05, 0x79, 0x27, 0xe8,
8267         0x2e, 0x4a, 0xa2, 0x22, 0x7c, 0x23, 0xdd, 0x2a, 0xa2, 0xe8, 0xaf, 0xc7, 0xbb, 0x0a, 0xf5, 0xfc,
8268         0x92, 0x0d, 0x85, 0xc4, 0x46, 0x0f, 0xa1, 0x64, 0xb8, 0xae, 0xe7, 0x1b, 0xc1, 0x83, 0x79, 0x51,
8269         0x98, 0xda, 0x99, 0xd9, 0xd4, 0x4e, 0x84, 0x31, 0xd6, 0xc5, 0xc4, 0x38, 0x38, 0x6e, 0x0a, 0x3d,
8270         0x80, 0x65, 0xef, 0x81, 0x4b, 0x28, 0x26, 0xc7, 0x84, 0x12, 0xd7, 0x24, 0xac, 0x52, 0x16, 0xd6,
8271         0xbf, 0x92, 0xd2, 0x7a, 0x42, 0x39, 0x0a, 0xe9, 0x24, 0x9d, 0xe1, 0x71, 0x2b, 0xa8, 0x0e, 0x70,
8272         0x6c, 0xbb, 0xb2, 0x17, 0xad, 0x2c, 0x45, 0x63, 0xb2, 0xeb, 0x8a, 0x8a, 0x63, 0x12, 0xe8, 0xab,
8273         0x50, 0x32, 0x9d, 0x3e, 0xf3, 0x49, 0x30, 0x8f, 0x5b, 0x16, 0x37, 0x48, 0xad, 0x6f, 0x37, 0x62,
8274         0xe1, 0xb8, 0x1c, 0x3a, 0x81, 0x45, 0x3b, 0xd6, 0xf4, 0x56, 0x56, 0x44, 0x2c, 0x6e, 0xcf, 0xdc,
8275         0xe9, 0xb2, 0xe6, 0x0a, 0xcf, 0x44, 0x71, 0x0a, 0x4e, 0x20, 0xaf, 0x7f, 0x0d, 0x4a, 0x9f, 0xb0,
8276         0x07, 0xe3, 0x3d, 0xdc, 0xf8, 0xd1, 0xcd, 0xd4, 0xc3, 0xfd, 0x25, 0x03, 0x4b, 0xc9, 0x0d, 0x57,
8277         0x6f, 0x1d, 0x6d, 0xea, 0x7c, 0x35, 0xcc, 0xca, 0xd9, 0xa9, 0x59, 0x59, 0x26, 0xbf, 0xf9, 0x17,
8278         0x49, 0x7e, 0xdb, 0x00, 0x46, 0xcf, 0x0e, 0xf3, 0x5e, 0x90, 0x47, 0x55, 0xe6, 0x8a, 0x26, 0x7e,
8279         0x38, 0x26, 0x25, 0x26, 0xa8, 0x9e, 0xeb, 0x53, 0xcf, 0x71, 0x08, 0x95, 0xc5, 0x34, 0x98, 0xa0,
8280         0x2a, 0x2a, 0x8e, 0x49, 0xa0, 0xeb, 0x80, 0x8e, 0x1c, 0xcf, 0x3c, 0x15, 0x5b, 0x10, 0xde, 0x73,
8281         0x91, 0x25, 0x0b, 0xc1, 0xe0, 0xaa, 0x39, 0xc1, 0xc5, 0x17, 0x68, 0xe8, 0x0b, 0x90, 0x6b, 0xf3,
8282         0xb6, 0x42, 0xbf, 0x0d, 0xc9, 0x99, 0x13, 0x7a, 0x27, 0xd8, 0x09, 0x4d, 0x0d, 0x85, 0x66, 0xdb,
8283         0x05, 0xfd, 0x0a, 0x14, 0xb1, 0xe7, 0xf9, 0x6d, 0xc3, 0x3f, 0x61, 0xa8, 0x06, 0xb9, 0x1e, 0xff,
8284         0x47, 0x8e, 0xfb, 0xc4, 0xac, 0x5a, 0x70, 0x70, 0x40, 0xd7, 0x7f, 0xa9, 0xc1, 0x2b, 0x53, 0xe7,
8285         0x8c, 0x7c, 0x47, 0x4d, 0xf5, 0x25, 0x5d, 0x52, 0x3b, 0x1a, 0xc9, 0xe1, 0x98, 0x14, 0xef, 0xc4,
8286         0x12, 0xc3, 0xc9, 0xf1, 0x4e, 0x2c, 0x61, 0x0d, 0x27, 0x65, 0xf5, 0x7f, 0x67, 0x20, 0x1f, 0x3c,
8287         0xcb, 0x3e, 0xe3, 0xe6, 0xfb, 0x75, 0xc8, 0x33, 0x61, 0x47, 0xba, 0xa7, 0xb2, 0x65, 0x60, 0x1d,
8288         0x4b, 0x2e, 0x6f, 0x62, 0xba, 0x84, 0x31, 0xa3, 0x13, 0x06, 0xaf, 0x6a, 0x62, 0x0e, 0x02, 0x32,
8289         0x0e, 0xf9, 0xe8, 0x6d, 0xfe, 0x0a, 0x35, 0x98, 0xea, 0x0b, 0xab, 0x21, 0x24, 0x16, 0xd4, 0xf3,
8290         0x61, 0x6d, 0x51, 0x82, 0x8b, 0x6f, 0x2c, 0xa5, 0xd1, 0x3d, 0x58, 0xb0, 0x88, 0x6f, 0xd8, 0x4e,
8291         0xd0, 0x0e, 0xa6, 0x9e, 0x5e, 0x06, 0x60, 0xad, 0x40, 0xb5, 0x59, 0xe2, 0x3e, 0xc9, 0x0f, 0x1c,
8292         0x02, 0xf2, 0x8b, 0x67, 0x7a, 0x56, 0xf0, 0x93, 0x42, 0x2e, 0xba, 0x78, 0xbb, 0x9e, 0x45, 0xb0,
8293         0xe0, 0xe8, 0x8f, 0x34, 0x28, 0x05, 0x48, 0xbb, 0x46, 0x9f, 0x11, 0xb4, 0xa5, 0x56, 0x11, 0x1c,
8294         0x77, 0x58, 0x93, 0xe7, 0xdf, 0x1b, 0xf4, 0xc8, 0xf9, 0xb0, 0x56, 0x14, 0x62, 0xfc, 0x43, 0x2d,
8295         0x20, 0xb6, 0x47, 0x99, 0x4b, 0xf6, 0xe8, 0x35, 0xc8, 0x89, 0xd6, 0x5b, 0x6e, 0xa6, 0x6a, 0xf4,
8296         0x44, 0x7b, 0x8e, 0x03, 0x9e, 0xfe, 0x71, 0x06, 0xca, 0x89, 0xc5, 0xa5, 0xe8, 0xea, 0xd4, 0xa8,
8297         0x24, 0x93, 0x62, 0xfc, 0x36, 0xfd, 0x87, 0xa0, 0xef, 0x42, 0xde, 0xe4, 0xeb, 0x0b, 0x7f, 0x89,
8298         0xdb, 0x9a, 0xe5, 0x28, 0xc4, 0xce, 0x44, 0x91, 0x24, 0x3e, 0x19, 0x96, 0x80, 0xe8, 0x06, 0xac,
8299         0x52, 0xe2, 0xd3, 0xc1, 0xce, 0xb1, 0x4f, 0x68, 0xbc, 0xff, 0xcf, 0x45, 0x7d, 0x0f, 0x1e, 0x17,
8300         0xc0, 0x93, 0x3a, 0x61, 0xaa, 0xcc, 0xbf, 0x40, 0xaa, 0xd4, 0x1d, 0x98, 0xff, 0x2f, 0xf6, 0xe8,
8301         0xdf, 0x83, 0x62, 0xd4, 0x45, 0x7d, 0xca, 0x26, 0xf5, 0x1f, 0x40, 0x81, 0x47, 0x63, 0xd8, 0xfd,
8302         0x5f, 0x52, 0x89, 0x92, 0x35, 0x22, 0x93, 0xa6, 0x46, 0xe8, 0x6f, 0x41, 0xf9, 0x4e, 0xcf, 0x9a,
8303         0xed, 0x57, 0x14, 0x7d, 0x1b, 0x82, 0x1f, 0x05, 0x79, 0x0a, 0x0e, 0x9e, 0xf9, 0xb1, 0x14, 0x1c,
8304         0x7f, 0xb3, 0x27, 0x7f, 0xaf, 0x01, 0xf1, 0xe6, 0xdc, 0x3b, 0x23, 0xae, 0xcf, 0x57, 0xc3, 0x8f,
8305         0x6d, 0x7c, 0x35, 0xe2, 0xee, 0x09, 0x0e, 0xba, 0x03, 0x79, 0x4f, 0xb4, 0x64, 0x72, 0xf0, 0x35,
8306         0xe3, 0x0c, 0x41, 0x85, 0x6a, 0xd0, 0xd7, 0x61, 0x09, 0xd6, 0xdc, 0x7c, 0xf2, 0xac, 0x3a, 0xf7,
8307         0xf4, 0x59, 0x75, 0xee, 0xa3, 0x67, 0xd5, 0xb9, 0x0f, 0x46, 0x55, 0xed, 0xc9, 0xa8, 0xaa, 0x3d,
8308         0x1d, 0x55, 0xb5, 0x8f, 0x46, 0x55, 0xed, 0xe3, 0x51, 0x55, 0x7b, 0xf4, 0x8f, 0xea, 0xdc, 0xbd,
8309         0xcc, 0xd9, 0xd6, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xab, 0xec, 0x02, 0x4a, 0x00, 0x21, 0x00,
8310         0x00,
8311 }