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

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