cmd/bpa-operator/vendor/k8s.io/api/apps/v1beta2/generated.pb.go

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