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

   1 /*
   2 Copyright The Kubernetes Authors.
   3
   4 Licensed under the Apache License, Version 2.0 (the "License");
   5 you may not use this file except in compliance with the License.
   6 You may obtain a copy of the License at
   7
   8     http://www.apache.org/licenses/LICENSE-2.0
   9
  10 Unless required by applicable law or agreed to in writing, software
  11 distributed under the License is distributed on an "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 See the License for the specific language governing permissions and
  14 limitations under the License.
  15 */
  16
  17 // Code generated by protoc-gen-gogo. DO NOT EDIT.
  18 // source: k8s.io/kubernetes/vendor/k8s.io/api/apps/v1beta1/generated.proto
  19
  20 /*
  21         Package v1beta1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/apps/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 ControllerRevision
  28                 ControllerRevisionList
  29                 Deployment
  30                 DeploymentCondition
  31                 DeploymentList
  32                 DeploymentRollback
  33                 DeploymentSpec
  34                 DeploymentStatus
  35                 DeploymentStrategy
  36                 RollbackConfig
  37                 RollingUpdateDeployment
  38                 RollingUpdateStatefulSetStrategy
  39                 Scale
  40                 ScaleSpec
  41                 ScaleStatus
  42                 StatefulSet
  43                 StatefulSetCondition
  44                 StatefulSetList
  45                 StatefulSetSpec
  46                 StatefulSetStatus
  47                 StatefulSetUpdateStrategy
  48 */
  49 package v1beta1
  50
  51 import proto "github.com/gogo/protobuf/proto"
  52 import fmt "fmt"
  53 import math "math"
  54
  55 import k8s_io_api_core_v1 "k8s.io/api/core/v1"
  56 import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  57
  58 import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr"
  59
  60 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  61
  62 import strings "strings"
  63 import reflect "reflect"
  64
  65 import io "io"
  66
  67 // Reference imports to suppress errors if they are not otherwise used.
  68 var _ = proto.Marshal
  69 var _ = fmt.Errorf
  70 var _ = math.Inf
  71
  72 // This is a compile-time assertion to ensure that this generated file
  73 // is compatible with the proto package it is being compiled against.
  74 // A compilation error at this line likely means your copy of the
  75 // proto package needs to be updated.
  76 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  77
  78 func (m *ControllerRevision) Reset()                    { *m = ControllerRevision{} }
  79 func (*ControllerRevision) ProtoMessage()               {}
  80 func (*ControllerRevision) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  81
  82 func (m *ControllerRevisionList) Reset()                    { *m = ControllerRevisionList{} }
  83 func (*ControllerRevisionList) ProtoMessage()               {}
  84 func (*ControllerRevisionList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  85
  86 func (m *Deployment) Reset()                    { *m = Deployment{} }
  87 func (*Deployment) ProtoMessage()               {}
  88 func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  89
  90 func (m *DeploymentCondition) Reset()                    { *m = DeploymentCondition{} }
  91 func (*DeploymentCondition) ProtoMessage()               {}
  92 func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
  93
  94 func (m *DeploymentList) Reset()                    { *m = DeploymentList{} }
  95 func (*DeploymentList) ProtoMessage()               {}
  96 func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
  97
  98 func (m *DeploymentRollback) Reset()                    { *m = DeploymentRollback{} }
  99 func (*DeploymentRollback) ProtoMessage()               {}
 100 func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
 101
 102 func (m *DeploymentSpec) Reset()                    { *m = DeploymentSpec{} }
 103 func (*DeploymentSpec) ProtoMessage()               {}
 104 func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
 105
 106 func (m *DeploymentStatus) Reset()                    { *m = DeploymentStatus{} }
 107 func (*DeploymentStatus) ProtoMessage()               {}
 108 func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
 109
 110 func (m *DeploymentStrategy) Reset()                    { *m = DeploymentStrategy{} }
 111 func (*DeploymentStrategy) ProtoMessage()               {}
 112 func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
 113
 114 func (m *RollbackConfig) Reset()                    { *m = RollbackConfig{} }
 115 func (*RollbackConfig) ProtoMessage()               {}
 116 func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
 117
 118 func (m *RollingUpdateDeployment) Reset()      { *m = RollingUpdateDeployment{} }
 119 func (*RollingUpdateDeployment) ProtoMessage() {}
 120 func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
 121         return fileDescriptorGenerated, []int{10}
 122 }
 123
 124 func (m *RollingUpdateStatefulSetStrategy) Reset()      { *m = RollingUpdateStatefulSetStrategy{} }
 125 func (*RollingUpdateStatefulSetStrategy) ProtoMessage() {}
 126 func (*RollingUpdateStatefulSetStrategy) Descriptor() ([]byte, []int) {
 127         return fileDescriptorGenerated, []int{11}
 128 }
 129
 130 func (m *Scale) Reset()                    { *m = Scale{} }
 131 func (*Scale) ProtoMessage()               {}
 132 func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
 133
 134 func (m *ScaleSpec) Reset()                    { *m = ScaleSpec{} }
 135 func (*ScaleSpec) ProtoMessage()               {}
 136 func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
 137
 138 func (m *ScaleStatus) Reset()                    { *m = ScaleStatus{} }
 139 func (*ScaleStatus) ProtoMessage()               {}
 140 func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
 141
 142 func (m *StatefulSet) Reset()                    { *m = StatefulSet{} }
 143 func (*StatefulSet) ProtoMessage()               {}
 144 func (*StatefulSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
 145
 146 func (m *StatefulSetCondition) Reset()                    { *m = StatefulSetCondition{} }
 147 func (*StatefulSetCondition) ProtoMessage()               {}
 148 func (*StatefulSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
 149
 150 func (m *StatefulSetList) Reset()                    { *m = StatefulSetList{} }
 151 func (*StatefulSetList) ProtoMessage()               {}
 152 func (*StatefulSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
 153
 154 func (m *StatefulSetSpec) Reset()                    { *m = StatefulSetSpec{} }
 155 func (*StatefulSetSpec) ProtoMessage()               {}
 156 func (*StatefulSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
 157
 158 func (m *StatefulSetStatus) Reset()                    { *m = StatefulSetStatus{} }
 159 func (*StatefulSetStatus) ProtoMessage()               {}
 160 func (*StatefulSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
 161
 162 func (m *StatefulSetUpdateStrategy) Reset()      { *m = StatefulSetUpdateStrategy{} }
 163 func (*StatefulSetUpdateStrategy) ProtoMessage() {}
 164 func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) {
 165         return fileDescriptorGenerated, []int{20}
 166 }
 167
 168 func init() {
 169         proto.RegisterType((*ControllerRevision)(nil), "k8s.io.api.apps.v1beta1.ControllerRevision")
 170         proto.RegisterType((*ControllerRevisionList)(nil), "k8s.io.api.apps.v1beta1.ControllerRevisionList")
 171         proto.RegisterType((*Deployment)(nil), "k8s.io.api.apps.v1beta1.Deployment")
 172         proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.apps.v1beta1.DeploymentCondition")
 173         proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.apps.v1beta1.DeploymentList")
 174         proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.apps.v1beta1.DeploymentRollback")
 175         proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.apps.v1beta1.DeploymentSpec")
 176         proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.apps.v1beta1.DeploymentStatus")
 177         proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.apps.v1beta1.DeploymentStrategy")
 178         proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.apps.v1beta1.RollbackConfig")
 179         proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.apps.v1beta1.RollingUpdateDeployment")
 180         proto.RegisterType((*RollingUpdateStatefulSetStrategy)(nil), "k8s.io.api.apps.v1beta1.RollingUpdateStatefulSetStrategy")
 181         proto.RegisterType((*Scale)(nil), "k8s.io.api.apps.v1beta1.Scale")
 182         proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.apps.v1beta1.ScaleSpec")
 183         proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.apps.v1beta1.ScaleStatus")
 184         proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1beta1.StatefulSet")
 185         proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1beta1.StatefulSetCondition")
 186         proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1beta1.StatefulSetList")
 187         proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1beta1.StatefulSetSpec")
 188         proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1beta1.StatefulSetStatus")
 189         proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1beta1.StatefulSetUpdateStrategy")
 190 }
 191 func (m *ControllerRevision) Marshal() (dAtA []byte, err error) {
 192         size := m.Size()
 193         dAtA = make([]byte, size)
 194         n, err := m.MarshalTo(dAtA)
 195         if err != nil {
 196                 return nil, err
 197         }
 198         return dAtA[:n], nil
 199 }
 200
 201 func (m *ControllerRevision) MarshalTo(dAtA []byte) (int, error) {
 202         var i int
 203         _ = i
 204         var l int
 205         _ = l
 206         dAtA[i] = 0xa
 207         i++
 208         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 209         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 210         if err != nil {
 211                 return 0, err
 212         }
 213         i += n1
 214         dAtA[i] = 0x12
 215         i++
 216         i = encodeVarintGenerated(dAtA, i, uint64(m.Data.Size()))
 217         n2, err := m.Data.MarshalTo(dAtA[i:])
 218         if err != nil {
 219                 return 0, err
 220         }
 221         i += n2
 222         dAtA[i] = 0x18
 223         i++
 224         i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
 225         return i, nil
 226 }
 227
 228 func (m *ControllerRevisionList) Marshal() (dAtA []byte, err error) {
 229         size := m.Size()
 230         dAtA = make([]byte, size)
 231         n, err := m.MarshalTo(dAtA)
 232         if err != nil {
 233                 return nil, err
 234         }
 235         return dAtA[:n], nil
 236 }
 237
 238 func (m *ControllerRevisionList) MarshalTo(dAtA []byte) (int, error) {
 239         var i int
 240         _ = i
 241         var l int
 242         _ = l
 243         dAtA[i] = 0xa
 244         i++
 245         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 246         n3, err := m.ListMeta.MarshalTo(dAtA[i:])
 247         if err != nil {
 248                 return 0, err
 249         }
 250         i += n3
 251         if len(m.Items) > 0 {
 252                 for _, msg := range m.Items {
 253                         dAtA[i] = 0x12
 254                         i++
 255                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 256                         n, err := msg.MarshalTo(dAtA[i:])
 257                         if err != nil {
 258                                 return 0, err
 259                         }
 260                         i += n
 261                 }
 262         }
 263         return i, nil
 264 }
 265
 266 func (m *Deployment) Marshal() (dAtA []byte, err error) {
 267         size := m.Size()
 268         dAtA = make([]byte, size)
 269         n, err := m.MarshalTo(dAtA)
 270         if err != nil {
 271                 return nil, err
 272         }
 273         return dAtA[:n], nil
 274 }
 275
 276 func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
 277         var i int
 278         _ = i
 279         var l int
 280         _ = l
 281         dAtA[i] = 0xa
 282         i++
 283         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 284         n4, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 285         if err != nil {
 286                 return 0, err
 287         }
 288         i += n4
 289         dAtA[i] = 0x12
 290         i++
 291         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 292         n5, err := m.Spec.MarshalTo(dAtA[i:])
 293         if err != nil {
 294                 return 0, err
 295         }
 296         i += n5
 297         dAtA[i] = 0x1a
 298         i++
 299         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 300         n6, err := m.Status.MarshalTo(dAtA[i:])
 301         if err != nil {
 302                 return 0, err
 303         }
 304         i += n6
 305         return i, nil
 306 }
 307
 308 func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
 309         size := m.Size()
 310         dAtA = make([]byte, size)
 311         n, err := m.MarshalTo(dAtA)
 312         if err != nil {
 313                 return nil, err
 314         }
 315         return dAtA[:n], nil
 316 }
 317
 318 func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
 319         var i int
 320         _ = i
 321         var l int
 322         _ = l
 323         dAtA[i] = 0xa
 324         i++
 325         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 326         i += copy(dAtA[i:], m.Type)
 327         dAtA[i] = 0x12
 328         i++
 329         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
 330         i += copy(dAtA[i:], m.Status)
 331         dAtA[i] = 0x22
 332         i++
 333         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 334         i += copy(dAtA[i:], m.Reason)
 335         dAtA[i] = 0x2a
 336         i++
 337         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 338         i += copy(dAtA[i:], m.Message)
 339         dAtA[i] = 0x32
 340         i++
 341         i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
 342         n7, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
 343         if err != nil {
 344                 return 0, err
 345         }
 346         i += n7
 347         dAtA[i] = 0x3a
 348         i++
 349         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
 350         n8, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
 351         if err != nil {
 352                 return 0, err
 353         }
 354         i += n8
 355         return i, nil
 356 }
 357
 358 func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
 359         size := m.Size()
 360         dAtA = make([]byte, size)
 361         n, err := m.MarshalTo(dAtA)
 362         if err != nil {
 363                 return nil, err
 364         }
 365         return dAtA[:n], nil
 366 }
 367
 368 func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
 369         var i int
 370         _ = i
 371         var l int
 372         _ = l
 373         dAtA[i] = 0xa
 374         i++
 375         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 376         n9, err := m.ListMeta.MarshalTo(dAtA[i:])
 377         if err != nil {
 378                 return 0, err
 379         }
 380         i += n9
 381         if len(m.Items) > 0 {
 382                 for _, msg := range m.Items {
 383                         dAtA[i] = 0x12
 384                         i++
 385                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 386                         n, err := msg.MarshalTo(dAtA[i:])
 387                         if err != nil {
 388                                 return 0, err
 389                         }
 390                         i += n
 391                 }
 392         }
 393         return i, nil
 394 }
 395
 396 func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) {
 397         size := m.Size()
 398         dAtA = make([]byte, size)
 399         n, err := m.MarshalTo(dAtA)
 400         if err != nil {
 401                 return nil, err
 402         }
 403         return dAtA[:n], nil
 404 }
 405
 406 func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) {
 407         var i int
 408         _ = i
 409         var l int
 410         _ = l
 411         dAtA[i] = 0xa
 412         i++
 413         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 414         i += copy(dAtA[i:], m.Name)
 415         if len(m.UpdatedAnnotations) > 0 {
 416                 keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations))
 417                 for k := range m.UpdatedAnnotations {
 418                         keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k))
 419                 }
 420                 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
 421                 for _, k := range keysForUpdatedAnnotations {
 422                         dAtA[i] = 0x12
 423                         i++
 424                         v := m.UpdatedAnnotations[string(k)]
 425                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 426                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 427                         dAtA[i] = 0xa
 428                         i++
 429                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 430                         i += copy(dAtA[i:], k)
 431                         dAtA[i] = 0x12
 432                         i++
 433                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
 434                         i += copy(dAtA[i:], v)
 435                 }
 436         }
 437         dAtA[i] = 0x1a
 438         i++
 439         i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
 440         n10, err := m.RollbackTo.MarshalTo(dAtA[i:])
 441         if err != nil {
 442                 return 0, err
 443         }
 444         i += n10
 445         return i, nil
 446 }
 447
 448 func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
 449         size := m.Size()
 450         dAtA = make([]byte, size)
 451         n, err := m.MarshalTo(dAtA)
 452         if err != nil {
 453                 return nil, err
 454         }
 455         return dAtA[:n], nil
 456 }
 457
 458 func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
 459         var i int
 460         _ = i
 461         var l int
 462         _ = l
 463         if m.Replicas != nil {
 464                 dAtA[i] = 0x8
 465                 i++
 466                 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
 467         }
 468         if m.Selector != nil {
 469                 dAtA[i] = 0x12
 470                 i++
 471                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 472                 n11, err := m.Selector.MarshalTo(dAtA[i:])
 473                 if err != nil {
 474                         return 0, err
 475                 }
 476                 i += n11
 477         }
 478         dAtA[i] = 0x1a
 479         i++
 480         i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
 481         n12, err := m.Template.MarshalTo(dAtA[i:])
 482         if err != nil {
 483                 return 0, err
 484         }
 485         i += n12
 486         dAtA[i] = 0x22
 487         i++
 488         i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size()))
 489         n13, err := m.Strategy.MarshalTo(dAtA[i:])
 490         if err != nil {
 491                 return 0, err
 492         }
 493         i += n13
 494         dAtA[i] = 0x28
 495         i++
 496         i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
 497         if m.RevisionHistoryLimit != nil {
 498                 dAtA[i] = 0x30
 499                 i++
 500                 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
 501         }
 502         dAtA[i] = 0x38
 503         i++
 504         if m.Paused {
 505                 dAtA[i] = 1
 506         } else {
 507                 dAtA[i] = 0
 508         }
 509         i++
 510         if m.RollbackTo != nil {
 511                 dAtA[i] = 0x42
 512                 i++
 513                 i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
 514                 n14, err := m.RollbackTo.MarshalTo(dAtA[i:])
 515                 if err != nil {
 516                         return 0, err
 517                 }
 518                 i += n14
 519         }
 520         if m.ProgressDeadlineSeconds != nil {
 521                 dAtA[i] = 0x48
 522                 i++
 523                 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
 524         }
 525         return i, nil
 526 }
 527
 528 func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
 529         size := m.Size()
 530         dAtA = make([]byte, size)
 531         n, err := m.MarshalTo(dAtA)
 532         if err != nil {
 533                 return nil, err
 534         }
 535         return dAtA[:n], nil
 536 }
 537
 538 func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
 539         var i int
 540         _ = i
 541         var l int
 542         _ = l
 543         dAtA[i] = 0x8
 544         i++
 545         i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
 546         dAtA[i] = 0x10
 547         i++
 548         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
 549         dAtA[i] = 0x18
 550         i++
 551         i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
 552         dAtA[i] = 0x20
 553         i++
 554         i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
 555         dAtA[i] = 0x28
 556         i++
 557         i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
 558         if len(m.Conditions) > 0 {
 559                 for _, msg := range m.Conditions {
 560                         dAtA[i] = 0x32
 561                         i++
 562                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 563                         n, err := msg.MarshalTo(dAtA[i:])
 564                         if err != nil {
 565                                 return 0, err
 566                         }
 567                         i += n
 568                 }
 569         }
 570         dAtA[i] = 0x38
 571         i++
 572         i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
 573         if m.CollisionCount != nil {
 574                 dAtA[i] = 0x40
 575                 i++
 576                 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
 577         }
 578         return i, nil
 579 }
 580
 581 func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
 582         size := m.Size()
 583         dAtA = make([]byte, size)
 584         n, err := m.MarshalTo(dAtA)
 585         if err != nil {
 586                 return nil, err
 587         }
 588         return dAtA[:n], nil
 589 }
 590
 591 func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
 592         var i int
 593         _ = i
 594         var l int
 595         _ = l
 596         dAtA[i] = 0xa
 597         i++
 598         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 599         i += copy(dAtA[i:], m.Type)
 600         if m.RollingUpdate != nil {
 601                 dAtA[i] = 0x12
 602                 i++
 603                 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
 604                 n15, err := m.RollingUpdate.MarshalTo(dAtA[i:])
 605                 if err != nil {
 606                         return 0, err
 607                 }
 608                 i += n15
 609         }
 610         return i, nil
 611 }
 612
 613 func (m *RollbackConfig) 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 *RollbackConfig) MarshalTo(dAtA []byte) (int, error) {
 624         var i int
 625         _ = i
 626         var l int
 627         _ = l
 628         dAtA[i] = 0x8
 629         i++
 630         i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
 631         return i, nil
 632 }
 633
 634 func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
 635         size := m.Size()
 636         dAtA = make([]byte, size)
 637         n, err := m.MarshalTo(dAtA)
 638         if err != nil {
 639                 return nil, err
 640         }
 641         return dAtA[:n], nil
 642 }
 643
 644 func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
 645         var i int
 646         _ = i
 647         var l int
 648         _ = l
 649         if m.MaxUnavailable != nil {
 650                 dAtA[i] = 0xa
 651                 i++
 652                 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
 653                 n16, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
 654                 if err != nil {
 655                         return 0, err
 656                 }
 657                 i += n16
 658         }
 659         if m.MaxSurge != nil {
 660                 dAtA[i] = 0x12
 661                 i++
 662                 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size()))
 663                 n17, err := m.MaxSurge.MarshalTo(dAtA[i:])
 664                 if err != nil {
 665                         return 0, err
 666                 }
 667                 i += n17
 668         }
 669         return i, nil
 670 }
 671
 672 func (m *RollingUpdateStatefulSetStrategy) Marshal() (dAtA []byte, err error) {
 673         size := m.Size()
 674         dAtA = make([]byte, size)
 675         n, err := m.MarshalTo(dAtA)
 676         if err != nil {
 677                 return nil, err
 678         }
 679         return dAtA[:n], nil
 680 }
 681
 682 func (m *RollingUpdateStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) {
 683         var i int
 684         _ = i
 685         var l int
 686         _ = l
 687         if m.Partition != nil {
 688                 dAtA[i] = 0x8
 689                 i++
 690                 i = encodeVarintGenerated(dAtA, i, uint64(*m.Partition))
 691         }
 692         return i, nil
 693 }
 694
 695 func (m *Scale) Marshal() (dAtA []byte, err error) {
 696         size := m.Size()
 697         dAtA = make([]byte, size)
 698         n, err := m.MarshalTo(dAtA)
 699         if err != nil {
 700                 return nil, err
 701         }
 702         return dAtA[:n], nil
 703 }
 704
 705 func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
 706         var i int
 707         _ = i
 708         var l int
 709         _ = l
 710         dAtA[i] = 0xa
 711         i++
 712         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 713         n18, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 714         if err != nil {
 715                 return 0, err
 716         }
 717         i += n18
 718         dAtA[i] = 0x12
 719         i++
 720         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 721         n19, err := m.Spec.MarshalTo(dAtA[i:])
 722         if err != nil {
 723                 return 0, err
 724         }
 725         i += n19
 726         dAtA[i] = 0x1a
 727         i++
 728         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 729         n20, err := m.Status.MarshalTo(dAtA[i:])
 730         if err != nil {
 731                 return 0, err
 732         }
 733         i += n20
 734         return i, nil
 735 }
 736
 737 func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
 738         size := m.Size()
 739         dAtA = make([]byte, size)
 740         n, err := m.MarshalTo(dAtA)
 741         if err != nil {
 742                 return nil, err
 743         }
 744         return dAtA[:n], nil
 745 }
 746
 747 func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
 748         var i int
 749         _ = i
 750         var l int
 751         _ = l
 752         dAtA[i] = 0x8
 753         i++
 754         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
 755         return i, nil
 756 }
 757
 758 func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
 759         size := m.Size()
 760         dAtA = make([]byte, size)
 761         n, err := m.MarshalTo(dAtA)
 762         if err != nil {
 763                 return nil, err
 764         }
 765         return dAtA[:n], nil
 766 }
 767
 768 func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
 769         var i int
 770         _ = i
 771         var l int
 772         _ = l
 773         dAtA[i] = 0x8
 774         i++
 775         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
 776         if len(m.Selector) > 0 {
 777                 keysForSelector := make([]string, 0, len(m.Selector))
 778                 for k := range m.Selector {
 779                         keysForSelector = append(keysForSelector, string(k))
 780                 }
 781                 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
 782                 for _, k := range keysForSelector {
 783                         dAtA[i] = 0x12
 784                         i++
 785                         v := m.Selector[string(k)]
 786                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 787                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 788                         dAtA[i] = 0xa
 789                         i++
 790                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 791                         i += copy(dAtA[i:], k)
 792                         dAtA[i] = 0x12
 793                         i++
 794                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
 795                         i += copy(dAtA[i:], v)
 796                 }
 797         }
 798         dAtA[i] = 0x1a
 799         i++
 800         i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector)))
 801         i += copy(dAtA[i:], m.TargetSelector)
 802         return i, nil
 803 }
 804
 805 func (m *StatefulSet) Marshal() (dAtA []byte, err error) {
 806         size := m.Size()
 807         dAtA = make([]byte, size)
 808         n, err := m.MarshalTo(dAtA)
 809         if err != nil {
 810                 return nil, err
 811         }
 812         return dAtA[:n], nil
 813 }
 814
 815 func (m *StatefulSet) MarshalTo(dAtA []byte) (int, error) {
 816         var i int
 817         _ = i
 818         var l int
 819         _ = l
 820         dAtA[i] = 0xa
 821         i++
 822         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 823         n21, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 824         if err != nil {
 825                 return 0, err
 826         }
 827         i += n21
 828         dAtA[i] = 0x12
 829         i++
 830         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 831         n22, err := m.Spec.MarshalTo(dAtA[i:])
 832         if err != nil {
 833                 return 0, err
 834         }
 835         i += n22
 836         dAtA[i] = 0x1a
 837         i++
 838         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 839         n23, err := m.Status.MarshalTo(dAtA[i:])
 840         if err != nil {
 841                 return 0, err
 842         }
 843         i += n23
 844         return i, nil
 845 }
 846
 847 func (m *StatefulSetCondition) Marshal() (dAtA []byte, err error) {
 848         size := m.Size()
 849         dAtA = make([]byte, size)
 850         n, err := m.MarshalTo(dAtA)
 851         if err != nil {
 852                 return nil, err
 853         }
 854         return dAtA[:n], nil
 855 }
 856
 857 func (m *StatefulSetCondition) MarshalTo(dAtA []byte) (int, error) {
 858         var i int
 859         _ = i
 860         var l int
 861         _ = l
 862         dAtA[i] = 0xa
 863         i++
 864         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 865         i += copy(dAtA[i:], m.Type)
 866         dAtA[i] = 0x12
 867         i++
 868         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
 869         i += copy(dAtA[i:], m.Status)
 870         dAtA[i] = 0x1a
 871         i++
 872         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
 873         n24, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
 874         if err != nil {
 875                 return 0, err
 876         }
 877         i += n24
 878         dAtA[i] = 0x22
 879         i++
 880         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 881         i += copy(dAtA[i:], m.Reason)
 882         dAtA[i] = 0x2a
 883         i++
 884         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 885         i += copy(dAtA[i:], m.Message)
 886         return i, nil
 887 }
 888
 889 func (m *StatefulSetList) Marshal() (dAtA []byte, err error) {
 890         size := m.Size()
 891         dAtA = make([]byte, size)
 892         n, err := m.MarshalTo(dAtA)
 893         if err != nil {
 894                 return nil, err
 895         }
 896         return dAtA[:n], nil
 897 }
 898
 899 func (m *StatefulSetList) MarshalTo(dAtA []byte) (int, error) {
 900         var i int
 901         _ = i
 902         var l int
 903         _ = l
 904         dAtA[i] = 0xa
 905         i++
 906         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 907         n25, err := m.ListMeta.MarshalTo(dAtA[i:])
 908         if err != nil {
 909                 return 0, err
 910         }
 911         i += n25
 912         if len(m.Items) > 0 {
 913                 for _, msg := range m.Items {
 914                         dAtA[i] = 0x12
 915                         i++
 916                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 917                         n, err := msg.MarshalTo(dAtA[i:])
 918                         if err != nil {
 919                                 return 0, err
 920                         }
 921                         i += n
 922                 }
 923         }
 924         return i, nil
 925 }
 926
 927 func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) {
 928         size := m.Size()
 929         dAtA = make([]byte, size)
 930         n, err := m.MarshalTo(dAtA)
 931         if err != nil {
 932                 return nil, err
 933         }
 934         return dAtA[:n], nil
 935 }
 936
 937 func (m *StatefulSetSpec) MarshalTo(dAtA []byte) (int, error) {
 938         var i int
 939         _ = i
 940         var l int
 941         _ = l
 942         if m.Replicas != nil {
 943                 dAtA[i] = 0x8
 944                 i++
 945                 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
 946         }
 947         if m.Selector != nil {
 948                 dAtA[i] = 0x12
 949                 i++
 950                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 951                 n26, err := m.Selector.MarshalTo(dAtA[i:])
 952                 if err != nil {
 953                         return 0, err
 954                 }
 955                 i += n26
 956         }
 957         dAtA[i] = 0x1a
 958         i++
 959         i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
 960         n27, err := m.Template.MarshalTo(dAtA[i:])
 961         if err != nil {
 962                 return 0, err
 963         }
 964         i += n27
 965         if len(m.VolumeClaimTemplates) > 0 {
 966                 for _, msg := range m.VolumeClaimTemplates {
 967                         dAtA[i] = 0x22
 968                         i++
 969                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 970                         n, err := msg.MarshalTo(dAtA[i:])
 971                         if err != nil {
 972                                 return 0, err
 973                         }
 974                         i += n
 975                 }
 976         }
 977         dAtA[i] = 0x2a
 978         i++
 979         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
 980         i += copy(dAtA[i:], m.ServiceName)
 981         dAtA[i] = 0x32
 982         i++
 983         i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodManagementPolicy)))
 984         i += copy(dAtA[i:], m.PodManagementPolicy)
 985         dAtA[i] = 0x3a
 986         i++
 987         i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size()))
 988         n28, err := m.UpdateStrategy.MarshalTo(dAtA[i:])
 989         if err != nil {
 990                 return 0, err
 991         }
 992         i += n28
 993         if m.RevisionHistoryLimit != nil {
 994                 dAtA[i] = 0x40
 995                 i++
 996                 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
 997         }
 998         return i, nil
 999 }
1000
1001 func (m *StatefulSetStatus) Marshal() (dAtA []byte, err error) {
1002         size := m.Size()
1003         dAtA = make([]byte, size)
1004         n, err := m.MarshalTo(dAtA)
1005         if err != nil {
1006                 return nil, err
1007         }
1008         return dAtA[:n], nil
1009 }
1010
1011 func (m *StatefulSetStatus) MarshalTo(dAtA []byte) (int, error) {
1012         var i int
1013         _ = i
1014         var l int
1015         _ = l
1016         if m.ObservedGeneration != nil {
1017                 dAtA[i] = 0x8
1018                 i++
1019                 i = encodeVarintGenerated(dAtA, i, uint64(*m.ObservedGeneration))
1020         }
1021         dAtA[i] = 0x10
1022         i++
1023         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1024         dAtA[i] = 0x18
1025         i++
1026         i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1027         dAtA[i] = 0x20
1028         i++
1029         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas))
1030         dAtA[i] = 0x28
1031         i++
1032         i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1033         dAtA[i] = 0x32
1034         i++
1035         i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentRevision)))
1036         i += copy(dAtA[i:], m.CurrentRevision)
1037         dAtA[i] = 0x3a
1038         i++
1039         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UpdateRevision)))
1040         i += copy(dAtA[i:], m.UpdateRevision)
1041         if m.CollisionCount != nil {
1042                 dAtA[i] = 0x48
1043                 i++
1044                 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1045         }
1046         if len(m.Conditions) > 0 {
1047                 for _, msg := range m.Conditions {
1048                         dAtA[i] = 0x52
1049                         i++
1050                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1051                         n, err := msg.MarshalTo(dAtA[i:])
1052                         if err != nil {
1053                                 return 0, err
1054                         }
1055                         i += n
1056                 }
1057         }
1058         return i, nil
1059 }
1060
1061 func (m *StatefulSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
1062         size := m.Size()
1063         dAtA = make([]byte, size)
1064         n, err := m.MarshalTo(dAtA)
1065         if err != nil {
1066                 return nil, err
1067         }
1068         return dAtA[:n], nil
1069 }
1070
1071 func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
1072         var i int
1073         _ = i
1074         var l int
1075         _ = l
1076         dAtA[i] = 0xa
1077         i++
1078         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1079         i += copy(dAtA[i:], m.Type)
1080         if m.RollingUpdate != nil {
1081                 dAtA[i] = 0x12
1082                 i++
1083                 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
1084                 n29, err := m.RollingUpdate.MarshalTo(dAtA[i:])
1085                 if err != nil {
1086                         return 0, err
1087                 }
1088                 i += n29
1089         }
1090         return i, nil
1091 }
1092
1093 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1094         for v >= 1<<7 {
1095                 dAtA[offset] = uint8(v&0x7f | 0x80)
1096                 v >>= 7
1097                 offset++
1098         }
1099         dAtA[offset] = uint8(v)
1100         return offset + 1
1101 }
1102 func (m *ControllerRevision) Size() (n int) {
1103         var l int
1104         _ = l
1105         l = m.ObjectMeta.Size()
1106         n += 1 + l + sovGenerated(uint64(l))
1107         l = m.Data.Size()
1108         n += 1 + l + sovGenerated(uint64(l))
1109         n += 1 + sovGenerated(uint64(m.Revision))
1110         return n
1111 }
1112
1113 func (m *ControllerRevisionList) Size() (n int) {
1114         var l int
1115         _ = l
1116         l = m.ListMeta.Size()
1117         n += 1 + l + sovGenerated(uint64(l))
1118         if len(m.Items) > 0 {
1119                 for _, e := range m.Items {
1120                         l = e.Size()
1121                         n += 1 + l + sovGenerated(uint64(l))
1122                 }
1123         }
1124         return n
1125 }
1126
1127 func (m *Deployment) Size() (n int) {
1128         var l int
1129         _ = l
1130         l = m.ObjectMeta.Size()
1131         n += 1 + l + sovGenerated(uint64(l))
1132         l = m.Spec.Size()
1133         n += 1 + l + sovGenerated(uint64(l))
1134         l = m.Status.Size()
1135         n += 1 + l + sovGenerated(uint64(l))
1136         return n
1137 }
1138
1139 func (m *DeploymentCondition) Size() (n int) {
1140         var l int
1141         _ = l
1142         l = len(m.Type)
1143         n += 1 + l + sovGenerated(uint64(l))
1144         l = len(m.Status)
1145         n += 1 + l + sovGenerated(uint64(l))
1146         l = len(m.Reason)
1147         n += 1 + l + sovGenerated(uint64(l))
1148         l = len(m.Message)
1149         n += 1 + l + sovGenerated(uint64(l))
1150         l = m.LastUpdateTime.Size()
1151         n += 1 + l + sovGenerated(uint64(l))
1152         l = m.LastTransitionTime.Size()
1153         n += 1 + l + sovGenerated(uint64(l))
1154         return n
1155 }
1156
1157 func (m *DeploymentList) Size() (n int) {
1158         var l int
1159         _ = l
1160         l = m.ListMeta.Size()
1161         n += 1 + l + sovGenerated(uint64(l))
1162         if len(m.Items) > 0 {
1163                 for _, e := range m.Items {
1164                         l = e.Size()
1165                         n += 1 + l + sovGenerated(uint64(l))
1166                 }
1167         }
1168         return n
1169 }
1170
1171 func (m *DeploymentRollback) Size() (n int) {
1172         var l int
1173         _ = l
1174         l = len(m.Name)
1175         n += 1 + l + sovGenerated(uint64(l))
1176         if len(m.UpdatedAnnotations) > 0 {
1177                 for k, v := range m.UpdatedAnnotations {
1178                         _ = k
1179                         _ = v
1180                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1181                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
1182                 }
1183         }
1184         l = m.RollbackTo.Size()
1185         n += 1 + l + sovGenerated(uint64(l))
1186         return n
1187 }
1188
1189 func (m *DeploymentSpec) Size() (n int) {
1190         var l int
1191         _ = l
1192         if m.Replicas != nil {
1193                 n += 1 + sovGenerated(uint64(*m.Replicas))
1194         }
1195         if m.Selector != nil {
1196                 l = m.Selector.Size()
1197                 n += 1 + l + sovGenerated(uint64(l))
1198         }
1199         l = m.Template.Size()
1200         n += 1 + l + sovGenerated(uint64(l))
1201         l = m.Strategy.Size()
1202         n += 1 + l + sovGenerated(uint64(l))
1203         n += 1 + sovGenerated(uint64(m.MinReadySeconds))
1204         if m.RevisionHistoryLimit != nil {
1205                 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
1206         }
1207         n += 2
1208         if m.RollbackTo != nil {
1209                 l = m.RollbackTo.Size()
1210                 n += 1 + l + sovGenerated(uint64(l))
1211         }
1212         if m.ProgressDeadlineSeconds != nil {
1213                 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
1214         }
1215         return n
1216 }
1217
1218 func (m *DeploymentStatus) Size() (n int) {
1219         var l int
1220         _ = l
1221         n += 1 + sovGenerated(uint64(m.ObservedGeneration))
1222         n += 1 + sovGenerated(uint64(m.Replicas))
1223         n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
1224         n += 1 + sovGenerated(uint64(m.AvailableReplicas))
1225         n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
1226         if len(m.Conditions) > 0 {
1227                 for _, e := range m.Conditions {
1228                         l = e.Size()
1229                         n += 1 + l + sovGenerated(uint64(l))
1230                 }
1231         }
1232         n += 1 + sovGenerated(uint64(m.ReadyReplicas))
1233         if m.CollisionCount != nil {
1234                 n += 1 + sovGenerated(uint64(*m.CollisionCount))
1235         }
1236         return n
1237 }
1238
1239 func (m *DeploymentStrategy) Size() (n int) {
1240         var l int
1241         _ = l
1242         l = len(m.Type)
1243         n += 1 + l + sovGenerated(uint64(l))
1244         if m.RollingUpdate != nil {
1245                 l = m.RollingUpdate.Size()
1246                 n += 1 + l + sovGenerated(uint64(l))
1247         }
1248         return n
1249 }
1250
1251 func (m *RollbackConfig) Size() (n int) {
1252         var l int
1253         _ = l
1254         n += 1 + sovGenerated(uint64(m.Revision))
1255         return n
1256 }
1257
1258 func (m *RollingUpdateDeployment) Size() (n int) {
1259         var l int
1260         _ = l
1261         if m.MaxUnavailable != nil {
1262                 l = m.MaxUnavailable.Size()
1263                 n += 1 + l + sovGenerated(uint64(l))
1264         }
1265         if m.MaxSurge != nil {
1266                 l = m.MaxSurge.Size()
1267                 n += 1 + l + sovGenerated(uint64(l))
1268         }
1269         return n
1270 }
1271
1272 func (m *RollingUpdateStatefulSetStrategy) Size() (n int) {
1273         var l int
1274         _ = l
1275         if m.Partition != nil {
1276                 n += 1 + sovGenerated(uint64(*m.Partition))
1277         }
1278         return n
1279 }
1280
1281 func (m *Scale) Size() (n int) {
1282         var l int
1283         _ = l
1284         l = m.ObjectMeta.Size()
1285         n += 1 + l + sovGenerated(uint64(l))
1286         l = m.Spec.Size()
1287         n += 1 + l + sovGenerated(uint64(l))
1288         l = m.Status.Size()
1289         n += 1 + l + sovGenerated(uint64(l))
1290         return n
1291 }
1292
1293 func (m *ScaleSpec) Size() (n int) {
1294         var l int
1295         _ = l
1296         n += 1 + sovGenerated(uint64(m.Replicas))
1297         return n
1298 }
1299
1300 func (m *ScaleStatus) Size() (n int) {
1301         var l int
1302         _ = l
1303         n += 1 + sovGenerated(uint64(m.Replicas))
1304         if len(m.Selector) > 0 {
1305                 for k, v := range m.Selector {
1306                         _ = k
1307                         _ = v
1308                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1309                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
1310                 }
1311         }
1312         l = len(m.TargetSelector)
1313         n += 1 + l + sovGenerated(uint64(l))
1314         return n
1315 }
1316
1317 func (m *StatefulSet) Size() (n int) {
1318         var l int
1319         _ = l
1320         l = m.ObjectMeta.Size()
1321         n += 1 + l + sovGenerated(uint64(l))
1322         l = m.Spec.Size()
1323         n += 1 + l + sovGenerated(uint64(l))
1324         l = m.Status.Size()
1325         n += 1 + l + sovGenerated(uint64(l))
1326         return n
1327 }
1328
1329 func (m *StatefulSetCondition) Size() (n int) {
1330         var l int
1331         _ = l
1332         l = len(m.Type)
1333         n += 1 + l + sovGenerated(uint64(l))
1334         l = len(m.Status)
1335         n += 1 + l + sovGenerated(uint64(l))
1336         l = m.LastTransitionTime.Size()
1337         n += 1 + l + sovGenerated(uint64(l))
1338         l = len(m.Reason)
1339         n += 1 + l + sovGenerated(uint64(l))
1340         l = len(m.Message)
1341         n += 1 + l + sovGenerated(uint64(l))
1342         return n
1343 }
1344
1345 func (m *StatefulSetList) Size() (n int) {
1346         var l int
1347         _ = l
1348         l = m.ListMeta.Size()
1349         n += 1 + l + sovGenerated(uint64(l))
1350         if len(m.Items) > 0 {
1351                 for _, e := range m.Items {
1352                         l = e.Size()
1353                         n += 1 + l + sovGenerated(uint64(l))
1354                 }
1355         }
1356         return n
1357 }
1358
1359 func (m *StatefulSetSpec) Size() (n int) {
1360         var l int
1361         _ = l
1362         if m.Replicas != nil {
1363                 n += 1 + sovGenerated(uint64(*m.Replicas))
1364         }
1365         if m.Selector != nil {
1366                 l = m.Selector.Size()
1367                 n += 1 + l + sovGenerated(uint64(l))
1368         }
1369         l = m.Template.Size()
1370         n += 1 + l + sovGenerated(uint64(l))
1371         if len(m.VolumeClaimTemplates) > 0 {
1372                 for _, e := range m.VolumeClaimTemplates {
1373                         l = e.Size()
1374                         n += 1 + l + sovGenerated(uint64(l))
1375                 }
1376         }
1377         l = len(m.ServiceName)
1378         n += 1 + l + sovGenerated(uint64(l))
1379         l = len(m.PodManagementPolicy)
1380         n += 1 + l + sovGenerated(uint64(l))
1381         l = m.UpdateStrategy.Size()
1382         n += 1 + l + sovGenerated(uint64(l))
1383         if m.RevisionHistoryLimit != nil {
1384                 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
1385         }
1386         return n
1387 }
1388
1389 func (m *StatefulSetStatus) Size() (n int) {
1390         var l int
1391         _ = l
1392         if m.ObservedGeneration != nil {
1393                 n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
1394         }
1395         n += 1 + sovGenerated(uint64(m.Replicas))
1396         n += 1 + sovGenerated(uint64(m.ReadyReplicas))
1397         n += 1 + sovGenerated(uint64(m.CurrentReplicas))
1398         n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
1399         l = len(m.CurrentRevision)
1400         n += 1 + l + sovGenerated(uint64(l))
1401         l = len(m.UpdateRevision)
1402         n += 1 + l + sovGenerated(uint64(l))
1403         if m.CollisionCount != nil {
1404                 n += 1 + sovGenerated(uint64(*m.CollisionCount))
1405         }
1406         if len(m.Conditions) > 0 {
1407                 for _, e := range m.Conditions {
1408                         l = e.Size()
1409                         n += 1 + l + sovGenerated(uint64(l))
1410                 }
1411         }
1412         return n
1413 }
1414
1415 func (m *StatefulSetUpdateStrategy) Size() (n int) {
1416         var l int
1417         _ = l
1418         l = len(m.Type)
1419         n += 1 + l + sovGenerated(uint64(l))
1420         if m.RollingUpdate != nil {
1421                 l = m.RollingUpdate.Size()
1422                 n += 1 + l + sovGenerated(uint64(l))
1423         }
1424         return n
1425 }
1426
1427 func sovGenerated(x uint64) (n int) {
1428         for {
1429                 n++
1430                 x >>= 7
1431                 if x == 0 {
1432                         break
1433                 }
1434         }
1435         return n
1436 }
1437 func sozGenerated(x uint64) (n int) {
1438         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1439 }
1440 func (this *ControllerRevision) String() string {
1441         if this == nil {
1442                 return "nil"
1443         }
1444         s := strings.Join([]string{`&ControllerRevision{`,
1445                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1446                 `Data:` + strings.Replace(strings.Replace(this.Data.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
1447                 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
1448                 `}`,
1449         }, "")
1450         return s
1451 }
1452 func (this *ControllerRevisionList) String() string {
1453         if this == nil {
1454                 return "nil"
1455         }
1456         s := strings.Join([]string{`&ControllerRevisionList{`,
1457                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1458                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ControllerRevision", "ControllerRevision", 1), `&`, ``, 1) + `,`,
1459                 `}`,
1460         }, "")
1461         return s
1462 }
1463 func (this *Deployment) String() string {
1464         if this == nil {
1465                 return "nil"
1466         }
1467         s := strings.Join([]string{`&Deployment{`,
1468                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1469                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
1470                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
1471                 `}`,
1472         }, "")
1473         return s
1474 }
1475 func (this *DeploymentCondition) String() string {
1476         if this == nil {
1477                 return "nil"
1478         }
1479         s := strings.Join([]string{`&DeploymentCondition{`,
1480                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1481                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
1482                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
1483                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
1484                 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
1485                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
1486                 `}`,
1487         }, "")
1488         return s
1489 }
1490 func (this *DeploymentList) String() string {
1491         if this == nil {
1492                 return "nil"
1493         }
1494         s := strings.Join([]string{`&DeploymentList{`,
1495                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1496                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`,
1497                 `}`,
1498         }, "")
1499         return s
1500 }
1501 func (this *DeploymentRollback) String() string {
1502         if this == nil {
1503                 return "nil"
1504         }
1505         keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations))
1506         for k := range this.UpdatedAnnotations {
1507                 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k)
1508         }
1509         github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
1510         mapStringForUpdatedAnnotations := "map[string]string{"
1511         for _, k := range keysForUpdatedAnnotations {
1512                 mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k])
1513         }
1514         mapStringForUpdatedAnnotations += "}"
1515         s := strings.Join([]string{`&DeploymentRollback{`,
1516                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
1517                 `UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`,
1518                 `RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`,
1519                 `}`,
1520         }, "")
1521         return s
1522 }
1523 func (this *DeploymentSpec) String() string {
1524         if this == nil {
1525                 return "nil"
1526         }
1527         s := strings.Join([]string{`&DeploymentSpec{`,
1528                 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
1529                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1530                 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
1531                 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
1532                 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
1533                 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
1534                 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
1535                 `RollbackTo:` + strings.Replace(fmt.Sprintf("%v", this.RollbackTo), "RollbackConfig", "RollbackConfig", 1) + `,`,
1536                 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
1537                 `}`,
1538         }, "")
1539         return s
1540 }
1541 func (this *DeploymentStatus) String() string {
1542         if this == nil {
1543                 return "nil"
1544         }
1545         s := strings.Join([]string{`&DeploymentStatus{`,
1546                 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
1547                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
1548                 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
1549                 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
1550                 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
1551                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`,
1552                 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
1553                 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
1554                 `}`,
1555         }, "")
1556         return s
1557 }
1558 func (this *DeploymentStrategy) String() string {
1559         if this == nil {
1560                 return "nil"
1561         }
1562         s := strings.Join([]string{`&DeploymentStrategy{`,
1563                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1564                 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
1565                 `}`,
1566         }, "")
1567         return s
1568 }
1569 func (this *RollbackConfig) String() string {
1570         if this == nil {
1571                 return "nil"
1572         }
1573         s := strings.Join([]string{`&RollbackConfig{`,
1574                 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
1575                 `}`,
1576         }, "")
1577         return s
1578 }
1579 func (this *RollingUpdateDeployment) String() string {
1580         if this == nil {
1581                 return "nil"
1582         }
1583         s := strings.Join([]string{`&RollingUpdateDeployment{`,
1584                 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
1585                 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
1586                 `}`,
1587         }, "")
1588         return s
1589 }
1590 func (this *RollingUpdateStatefulSetStrategy) String() string {
1591         if this == nil {
1592                 return "nil"
1593         }
1594         s := strings.Join([]string{`&RollingUpdateStatefulSetStrategy{`,
1595                 `Partition:` + valueToStringGenerated(this.Partition) + `,`,
1596                 `}`,
1597         }, "")
1598         return s
1599 }
1600 func (this *Scale) String() string {
1601         if this == nil {
1602                 return "nil"
1603         }
1604         s := strings.Join([]string{`&Scale{`,
1605                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1606                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
1607                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
1608                 `}`,
1609         }, "")
1610         return s
1611 }
1612 func (this *ScaleSpec) String() string {
1613         if this == nil {
1614                 return "nil"
1615         }
1616         s := strings.Join([]string{`&ScaleSpec{`,
1617                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
1618                 `}`,
1619         }, "")
1620         return s
1621 }
1622 func (this *ScaleStatus) String() string {
1623         if this == nil {
1624                 return "nil"
1625         }
1626         keysForSelector := make([]string, 0, len(this.Selector))
1627         for k := range this.Selector {
1628                 keysForSelector = append(keysForSelector, k)
1629         }
1630         github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
1631         mapStringForSelector := "map[string]string{"
1632         for _, k := range keysForSelector {
1633                 mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k])
1634         }
1635         mapStringForSelector += "}"
1636         s := strings.Join([]string{`&ScaleStatus{`,
1637                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
1638                 `Selector:` + mapStringForSelector + `,`,
1639                 `TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`,
1640                 `}`,
1641         }, "")
1642         return s
1643 }
1644 func (this *StatefulSet) String() string {
1645         if this == nil {
1646                 return "nil"
1647         }
1648         s := strings.Join([]string{`&StatefulSet{`,
1649                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1650                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "StatefulSetSpec", "StatefulSetSpec", 1), `&`, ``, 1) + `,`,
1651                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "StatefulSetStatus", "StatefulSetStatus", 1), `&`, ``, 1) + `,`,
1652                 `}`,
1653         }, "")
1654         return s
1655 }
1656 func (this *StatefulSetCondition) String() string {
1657         if this == nil {
1658                 return "nil"
1659         }
1660         s := strings.Join([]string{`&StatefulSetCondition{`,
1661                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1662                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
1663                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
1664                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
1665                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
1666                 `}`,
1667         }, "")
1668         return s
1669 }
1670 func (this *StatefulSetList) String() string {
1671         if this == nil {
1672                 return "nil"
1673         }
1674         s := strings.Join([]string{`&StatefulSetList{`,
1675                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1676                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "StatefulSet", "StatefulSet", 1), `&`, ``, 1) + `,`,
1677                 `}`,
1678         }, "")
1679         return s
1680 }
1681 func (this *StatefulSetSpec) String() string {
1682         if this == nil {
1683                 return "nil"
1684         }
1685         s := strings.Join([]string{`&StatefulSetSpec{`,
1686                 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
1687                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1688                 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
1689                 `VolumeClaimTemplates:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.VolumeClaimTemplates), "PersistentVolumeClaim", "k8s_io_api_core_v1.PersistentVolumeClaim", 1), `&`, ``, 1) + `,`,
1690                 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
1691                 `PodManagementPolicy:` + fmt.Sprintf("%v", this.PodManagementPolicy) + `,`,
1692                 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
1693                 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
1694                 `}`,
1695         }, "")
1696         return s
1697 }
1698 func (this *StatefulSetStatus) String() string {
1699         if this == nil {
1700                 return "nil"
1701         }
1702         s := strings.Join([]string{`&StatefulSetStatus{`,
1703                 `ObservedGeneration:` + valueToStringGenerated(this.ObservedGeneration) + `,`,
1704                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
1705                 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
1706                 `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`,
1707                 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
1708                 `CurrentRevision:` + fmt.Sprintf("%v", this.CurrentRevision) + `,`,
1709                 `UpdateRevision:` + fmt.Sprintf("%v", this.UpdateRevision) + `,`,
1710                 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
1711                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "StatefulSetCondition", "StatefulSetCondition", 1), `&`, ``, 1) + `,`,
1712                 `}`,
1713         }, "")
1714         return s
1715 }
1716 func (this *StatefulSetUpdateStrategy) String() string {
1717         if this == nil {
1718                 return "nil"
1719         }
1720         s := strings.Join([]string{`&StatefulSetUpdateStrategy{`,
1721                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1722                 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateStatefulSetStrategy", "RollingUpdateStatefulSetStrategy", 1) + `,`,
1723                 `}`,
1724         }, "")
1725         return s
1726 }
1727 func valueToStringGenerated(v interface{}) string {
1728         rv := reflect.ValueOf(v)
1729         if rv.IsNil() {
1730                 return "nil"
1731         }
1732         pv := reflect.Indirect(rv).Interface()
1733         return fmt.Sprintf("*%v", pv)
1734 }
1735 func (m *ControllerRevision) Unmarshal(dAtA []byte) error {
1736         l := len(dAtA)
1737         iNdEx := 0
1738         for iNdEx < l {
1739                 preIndex := iNdEx
1740                 var wire uint64
1741                 for shift := uint(0); ; shift += 7 {
1742                         if shift >= 64 {
1743                                 return ErrIntOverflowGenerated
1744                         }
1745                         if iNdEx >= l {
1746                                 return io.ErrUnexpectedEOF
1747                         }
1748                         b := dAtA[iNdEx]
1749                         iNdEx++
1750                         wire |= (uint64(b) & 0x7F) << shift
1751                         if b < 0x80 {
1752                                 break
1753                         }
1754                 }
1755                 fieldNum := int32(wire >> 3)
1756                 wireType := int(wire & 0x7)
1757                 if wireType == 4 {
1758                         return fmt.Errorf("proto: ControllerRevision: wiretype end group for non-group")
1759                 }
1760                 if fieldNum <= 0 {
1761                         return fmt.Errorf("proto: ControllerRevision: illegal tag %d (wire type %d)", fieldNum, wire)
1762                 }
1763                 switch fieldNum {
1764                 case 1:
1765                         if wireType != 2 {
1766                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1767                         }
1768                         var msglen int
1769                         for shift := uint(0); ; shift += 7 {
1770                                 if shift >= 64 {
1771                                         return ErrIntOverflowGenerated
1772                                 }
1773                                 if iNdEx >= l {
1774                                         return io.ErrUnexpectedEOF
1775                                 }
1776                                 b := dAtA[iNdEx]
1777                                 iNdEx++
1778                                 msglen |= (int(b) & 0x7F) << shift
1779                                 if b < 0x80 {
1780                                         break
1781                                 }
1782                         }
1783                         if msglen < 0 {
1784                                 return ErrInvalidLengthGenerated
1785                         }
1786                         postIndex := iNdEx + msglen
1787                         if postIndex > l {
1788                                 return io.ErrUnexpectedEOF
1789                         }
1790                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1791                                 return err
1792                         }
1793                         iNdEx = postIndex
1794                 case 2:
1795                         if wireType != 2 {
1796                                 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
1797                         }
1798                         var msglen int
1799                         for shift := uint(0); ; shift += 7 {
1800                                 if shift >= 64 {
1801                                         return ErrIntOverflowGenerated
1802                                 }
1803                                 if iNdEx >= l {
1804                                         return io.ErrUnexpectedEOF
1805                                 }
1806                                 b := dAtA[iNdEx]
1807                                 iNdEx++
1808                                 msglen |= (int(b) & 0x7F) << shift
1809                                 if b < 0x80 {
1810                                         break
1811                                 }
1812                         }
1813                         if msglen < 0 {
1814                                 return ErrInvalidLengthGenerated
1815                         }
1816                         postIndex := iNdEx + msglen
1817                         if postIndex > l {
1818                                 return io.ErrUnexpectedEOF
1819                         }
1820                         if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1821                                 return err
1822                         }
1823                         iNdEx = postIndex
1824                 case 3:
1825                         if wireType != 0 {
1826                                 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
1827                         }
1828                         m.Revision = 0
1829                         for shift := uint(0); ; shift += 7 {
1830                                 if shift >= 64 {
1831                                         return ErrIntOverflowGenerated
1832                                 }
1833                                 if iNdEx >= l {
1834                                         return io.ErrUnexpectedEOF
1835                                 }
1836                                 b := dAtA[iNdEx]
1837                                 iNdEx++
1838                                 m.Revision |= (int64(b) & 0x7F) << shift
1839                                 if b < 0x80 {
1840                                         break
1841                                 }
1842                         }
1843                 default:
1844                         iNdEx = preIndex
1845                         skippy, err := skipGenerated(dAtA[iNdEx:])
1846                         if err != nil {
1847                                 return err
1848                         }
1849                         if skippy < 0 {
1850                                 return ErrInvalidLengthGenerated
1851                         }
1852                         if (iNdEx + skippy) > l {
1853                                 return io.ErrUnexpectedEOF
1854                         }
1855                         iNdEx += skippy
1856                 }
1857         }
1858
1859         if iNdEx > l {
1860                 return io.ErrUnexpectedEOF
1861         }
1862         return nil
1863 }
1864 func (m *ControllerRevisionList) Unmarshal(dAtA []byte) error {
1865         l := len(dAtA)
1866         iNdEx := 0
1867         for iNdEx < l {
1868                 preIndex := iNdEx
1869                 var wire uint64
1870                 for shift := uint(0); ; shift += 7 {
1871                         if shift >= 64 {
1872                                 return ErrIntOverflowGenerated
1873                         }
1874                         if iNdEx >= l {
1875                                 return io.ErrUnexpectedEOF
1876                         }
1877                         b := dAtA[iNdEx]
1878                         iNdEx++
1879                         wire |= (uint64(b) & 0x7F) << shift
1880                         if b < 0x80 {
1881                                 break
1882                         }
1883                 }
1884                 fieldNum := int32(wire >> 3)
1885                 wireType := int(wire & 0x7)
1886                 if wireType == 4 {
1887                         return fmt.Errorf("proto: ControllerRevisionList: wiretype end group for non-group")
1888                 }
1889                 if fieldNum <= 0 {
1890                         return fmt.Errorf("proto: ControllerRevisionList: illegal tag %d (wire type %d)", fieldNum, wire)
1891                 }
1892                 switch fieldNum {
1893                 case 1:
1894                         if wireType != 2 {
1895                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1896                         }
1897                         var msglen int
1898                         for shift := uint(0); ; shift += 7 {
1899                                 if shift >= 64 {
1900                                         return ErrIntOverflowGenerated
1901                                 }
1902                                 if iNdEx >= l {
1903                                         return io.ErrUnexpectedEOF
1904                                 }
1905                                 b := dAtA[iNdEx]
1906                                 iNdEx++
1907                                 msglen |= (int(b) & 0x7F) << shift
1908                                 if b < 0x80 {
1909                                         break
1910                                 }
1911                         }
1912                         if msglen < 0 {
1913                                 return ErrInvalidLengthGenerated
1914                         }
1915                         postIndex := iNdEx + msglen
1916                         if postIndex > l {
1917                                 return io.ErrUnexpectedEOF
1918                         }
1919                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1920                                 return err
1921                         }
1922                         iNdEx = postIndex
1923                 case 2:
1924                         if wireType != 2 {
1925                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1926                         }
1927                         var msglen int
1928                         for shift := uint(0); ; shift += 7 {
1929                                 if shift >= 64 {
1930                                         return ErrIntOverflowGenerated
1931                                 }
1932                                 if iNdEx >= l {
1933                                         return io.ErrUnexpectedEOF
1934                                 }
1935                                 b := dAtA[iNdEx]
1936                                 iNdEx++
1937                                 msglen |= (int(b) & 0x7F) << shift
1938                                 if b < 0x80 {
1939                                         break
1940                                 }
1941                         }
1942                         if msglen < 0 {
1943                                 return ErrInvalidLengthGenerated
1944                         }
1945                         postIndex := iNdEx + msglen
1946                         if postIndex > l {
1947                                 return io.ErrUnexpectedEOF
1948                         }
1949                         m.Items = append(m.Items, ControllerRevision{})
1950                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1951                                 return err
1952                         }
1953                         iNdEx = postIndex
1954                 default:
1955                         iNdEx = preIndex
1956                         skippy, err := skipGenerated(dAtA[iNdEx:])
1957                         if err != nil {
1958                                 return err
1959                         }
1960                         if skippy < 0 {
1961                                 return ErrInvalidLengthGenerated
1962                         }
1963                         if (iNdEx + skippy) > l {
1964                                 return io.ErrUnexpectedEOF
1965                         }
1966                         iNdEx += skippy
1967                 }
1968         }
1969
1970         if iNdEx > l {
1971                 return io.ErrUnexpectedEOF
1972         }
1973         return nil
1974 }
1975 func (m *Deployment) Unmarshal(dAtA []byte) error {
1976         l := len(dAtA)
1977         iNdEx := 0
1978         for iNdEx < l {
1979                 preIndex := iNdEx
1980                 var wire uint64
1981                 for shift := uint(0); ; shift += 7 {
1982                         if shift >= 64 {
1983                                 return ErrIntOverflowGenerated
1984                         }
1985                         if iNdEx >= l {
1986                                 return io.ErrUnexpectedEOF
1987                         }
1988                         b := dAtA[iNdEx]
1989                         iNdEx++
1990                         wire |= (uint64(b) & 0x7F) << shift
1991                         if b < 0x80 {
1992                                 break
1993                         }
1994                 }
1995                 fieldNum := int32(wire >> 3)
1996                 wireType := int(wire & 0x7)
1997                 if wireType == 4 {
1998                         return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
1999                 }
2000                 if fieldNum <= 0 {
2001                         return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
2002                 }
2003                 switch fieldNum {
2004                 case 1:
2005                         if wireType != 2 {
2006                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2007                         }
2008                         var msglen int
2009                         for shift := uint(0); ; shift += 7 {
2010                                 if shift >= 64 {
2011                                         return ErrIntOverflowGenerated
2012                                 }
2013                                 if iNdEx >= l {
2014                                         return io.ErrUnexpectedEOF
2015                                 }
2016                                 b := dAtA[iNdEx]
2017                                 iNdEx++
2018                                 msglen |= (int(b) & 0x7F) << shift
2019                                 if b < 0x80 {
2020                                         break
2021                                 }
2022                         }
2023                         if msglen < 0 {
2024                                 return ErrInvalidLengthGenerated
2025                         }
2026                         postIndex := iNdEx + msglen
2027                         if postIndex > l {
2028                                 return io.ErrUnexpectedEOF
2029                         }
2030                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2031                                 return err
2032                         }
2033                         iNdEx = postIndex
2034                 case 2:
2035                         if wireType != 2 {
2036                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2037                         }
2038                         var msglen int
2039                         for shift := uint(0); ; shift += 7 {
2040                                 if shift >= 64 {
2041                                         return ErrIntOverflowGenerated
2042                                 }
2043                                 if iNdEx >= l {
2044                                         return io.ErrUnexpectedEOF
2045                                 }
2046                                 b := dAtA[iNdEx]
2047                                 iNdEx++
2048                                 msglen |= (int(b) & 0x7F) << shift
2049                                 if b < 0x80 {
2050                                         break
2051                                 }
2052                         }
2053                         if msglen < 0 {
2054                                 return ErrInvalidLengthGenerated
2055                         }
2056                         postIndex := iNdEx + msglen
2057                         if postIndex > l {
2058                                 return io.ErrUnexpectedEOF
2059                         }
2060                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2061                                 return err
2062                         }
2063                         iNdEx = postIndex
2064                 case 3:
2065                         if wireType != 2 {
2066                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2067                         }
2068                         var msglen int
2069                         for shift := uint(0); ; shift += 7 {
2070                                 if shift >= 64 {
2071                                         return ErrIntOverflowGenerated
2072                                 }
2073                                 if iNdEx >= l {
2074                                         return io.ErrUnexpectedEOF
2075                                 }
2076                                 b := dAtA[iNdEx]
2077                                 iNdEx++
2078                                 msglen |= (int(b) & 0x7F) << shift
2079                                 if b < 0x80 {
2080                                         break
2081                                 }
2082                         }
2083                         if msglen < 0 {
2084                                 return ErrInvalidLengthGenerated
2085                         }
2086                         postIndex := iNdEx + msglen
2087                         if postIndex > l {
2088                                 return io.ErrUnexpectedEOF
2089                         }
2090                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2091                                 return err
2092                         }
2093                         iNdEx = postIndex
2094                 default:
2095                         iNdEx = preIndex
2096                         skippy, err := skipGenerated(dAtA[iNdEx:])
2097                         if err != nil {
2098                                 return err
2099                         }
2100                         if skippy < 0 {
2101                                 return ErrInvalidLengthGenerated
2102                         }
2103                         if (iNdEx + skippy) > l {
2104                                 return io.ErrUnexpectedEOF
2105                         }
2106                         iNdEx += skippy
2107                 }
2108         }
2109
2110         if iNdEx > l {
2111                 return io.ErrUnexpectedEOF
2112         }
2113         return nil
2114 }
2115 func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
2116         l := len(dAtA)
2117         iNdEx := 0
2118         for iNdEx < l {
2119                 preIndex := iNdEx
2120                 var wire uint64
2121                 for shift := uint(0); ; shift += 7 {
2122                         if shift >= 64 {
2123                                 return ErrIntOverflowGenerated
2124                         }
2125                         if iNdEx >= l {
2126                                 return io.ErrUnexpectedEOF
2127                         }
2128                         b := dAtA[iNdEx]
2129                         iNdEx++
2130                         wire |= (uint64(b) & 0x7F) << shift
2131                         if b < 0x80 {
2132                                 break
2133                         }
2134                 }
2135                 fieldNum := int32(wire >> 3)
2136                 wireType := int(wire & 0x7)
2137                 if wireType == 4 {
2138                         return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
2139                 }
2140                 if fieldNum <= 0 {
2141                         return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
2142                 }
2143                 switch fieldNum {
2144                 case 1:
2145                         if wireType != 2 {
2146                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2147                         }
2148                         var stringLen uint64
2149                         for shift := uint(0); ; shift += 7 {
2150                                 if shift >= 64 {
2151                                         return ErrIntOverflowGenerated
2152                                 }
2153                                 if iNdEx >= l {
2154                                         return io.ErrUnexpectedEOF
2155                                 }
2156                                 b := dAtA[iNdEx]
2157                                 iNdEx++
2158                                 stringLen |= (uint64(b) & 0x7F) << shift
2159                                 if b < 0x80 {
2160                                         break
2161                                 }
2162                         }
2163                         intStringLen := int(stringLen)
2164                         if intStringLen < 0 {
2165                                 return ErrInvalidLengthGenerated
2166                         }
2167                         postIndex := iNdEx + intStringLen
2168                         if postIndex > l {
2169                                 return io.ErrUnexpectedEOF
2170                         }
2171                         m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
2172                         iNdEx = postIndex
2173                 case 2:
2174                         if wireType != 2 {
2175                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2176                         }
2177                         var stringLen uint64
2178                         for shift := uint(0); ; shift += 7 {
2179                                 if shift >= 64 {
2180                                         return ErrIntOverflowGenerated
2181                                 }
2182                                 if iNdEx >= l {
2183                                         return io.ErrUnexpectedEOF
2184                                 }
2185                                 b := dAtA[iNdEx]
2186                                 iNdEx++
2187                                 stringLen |= (uint64(b) & 0x7F) << shift
2188                                 if b < 0x80 {
2189                                         break
2190                                 }
2191                         }
2192                         intStringLen := int(stringLen)
2193                         if intStringLen < 0 {
2194                                 return ErrInvalidLengthGenerated
2195                         }
2196                         postIndex := iNdEx + intStringLen
2197                         if postIndex > l {
2198                                 return io.ErrUnexpectedEOF
2199                         }
2200                         m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
2201                         iNdEx = postIndex
2202                 case 4:
2203                         if wireType != 2 {
2204                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
2205                         }
2206                         var stringLen uint64
2207                         for shift := uint(0); ; shift += 7 {
2208                                 if shift >= 64 {
2209                                         return ErrIntOverflowGenerated
2210                                 }
2211                                 if iNdEx >= l {
2212                                         return io.ErrUnexpectedEOF
2213                                 }
2214                                 b := dAtA[iNdEx]
2215                                 iNdEx++
2216                                 stringLen |= (uint64(b) & 0x7F) << shift
2217                                 if b < 0x80 {
2218                                         break
2219                                 }
2220                         }
2221                         intStringLen := int(stringLen)
2222                         if intStringLen < 0 {
2223                                 return ErrInvalidLengthGenerated
2224                         }
2225                         postIndex := iNdEx + intStringLen
2226                         if postIndex > l {
2227                                 return io.ErrUnexpectedEOF
2228                         }
2229                         m.Reason = string(dAtA[iNdEx:postIndex])
2230                         iNdEx = postIndex
2231                 case 5:
2232                         if wireType != 2 {
2233                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
2234                         }
2235                         var stringLen uint64
2236                         for shift := uint(0); ; shift += 7 {
2237                                 if shift >= 64 {
2238                                         return ErrIntOverflowGenerated
2239                                 }
2240                                 if iNdEx >= l {
2241                                         return io.ErrUnexpectedEOF
2242                                 }
2243                                 b := dAtA[iNdEx]
2244                                 iNdEx++
2245                                 stringLen |= (uint64(b) & 0x7F) << shift
2246                                 if b < 0x80 {
2247                                         break
2248                                 }
2249                         }
2250                         intStringLen := int(stringLen)
2251                         if intStringLen < 0 {
2252                                 return ErrInvalidLengthGenerated
2253                         }
2254                         postIndex := iNdEx + intStringLen
2255                         if postIndex > l {
2256                                 return io.ErrUnexpectedEOF
2257                         }
2258                         m.Message = string(dAtA[iNdEx:postIndex])
2259                         iNdEx = postIndex
2260                 case 6:
2261                         if wireType != 2 {
2262                                 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
2263                         }
2264                         var msglen int
2265                         for shift := uint(0); ; shift += 7 {
2266                                 if shift >= 64 {
2267                                         return ErrIntOverflowGenerated
2268                                 }
2269                                 if iNdEx >= l {
2270                                         return io.ErrUnexpectedEOF
2271                                 }
2272                                 b := dAtA[iNdEx]
2273                                 iNdEx++
2274                                 msglen |= (int(b) & 0x7F) << shift
2275                                 if b < 0x80 {
2276                                         break
2277                                 }
2278                         }
2279                         if msglen < 0 {
2280                                 return ErrInvalidLengthGenerated
2281                         }
2282                         postIndex := iNdEx + msglen
2283                         if postIndex > l {
2284                                 return io.ErrUnexpectedEOF
2285                         }
2286                         if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2287                                 return err
2288                         }
2289                         iNdEx = postIndex
2290                 case 7:
2291                         if wireType != 2 {
2292                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
2293                         }
2294                         var msglen int
2295                         for shift := uint(0); ; shift += 7 {
2296                                 if shift >= 64 {
2297                                         return ErrIntOverflowGenerated
2298                                 }
2299                                 if iNdEx >= l {
2300                                         return io.ErrUnexpectedEOF
2301                                 }
2302                                 b := dAtA[iNdEx]
2303                                 iNdEx++
2304                                 msglen |= (int(b) & 0x7F) << shift
2305                                 if b < 0x80 {
2306                                         break
2307                                 }
2308                         }
2309                         if msglen < 0 {
2310                                 return ErrInvalidLengthGenerated
2311                         }
2312                         postIndex := iNdEx + msglen
2313                         if postIndex > l {
2314                                 return io.ErrUnexpectedEOF
2315                         }
2316                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2317                                 return err
2318                         }
2319                         iNdEx = postIndex
2320                 default:
2321                         iNdEx = preIndex
2322                         skippy, err := skipGenerated(dAtA[iNdEx:])
2323                         if err != nil {
2324                                 return err
2325                         }
2326                         if skippy < 0 {
2327                                 return ErrInvalidLengthGenerated
2328                         }
2329                         if (iNdEx + skippy) > l {
2330                                 return io.ErrUnexpectedEOF
2331                         }
2332                         iNdEx += skippy
2333                 }
2334         }
2335
2336         if iNdEx > l {
2337                 return io.ErrUnexpectedEOF
2338         }
2339         return nil
2340 }
2341 func (m *DeploymentList) Unmarshal(dAtA []byte) error {
2342         l := len(dAtA)
2343         iNdEx := 0
2344         for iNdEx < l {
2345                 preIndex := iNdEx
2346                 var wire uint64
2347                 for shift := uint(0); ; shift += 7 {
2348                         if shift >= 64 {
2349                                 return ErrIntOverflowGenerated
2350                         }
2351                         if iNdEx >= l {
2352                                 return io.ErrUnexpectedEOF
2353                         }
2354                         b := dAtA[iNdEx]
2355                         iNdEx++
2356                         wire |= (uint64(b) & 0x7F) << shift
2357                         if b < 0x80 {
2358                                 break
2359                         }
2360                 }
2361                 fieldNum := int32(wire >> 3)
2362                 wireType := int(wire & 0x7)
2363                 if wireType == 4 {
2364                         return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
2365                 }
2366                 if fieldNum <= 0 {
2367                         return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
2368                 }
2369                 switch fieldNum {
2370                 case 1:
2371                         if wireType != 2 {
2372                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2373                         }
2374                         var msglen int
2375                         for shift := uint(0); ; shift += 7 {
2376                                 if shift >= 64 {
2377                                         return ErrIntOverflowGenerated
2378                                 }
2379                                 if iNdEx >= l {
2380                                         return io.ErrUnexpectedEOF
2381                                 }
2382                                 b := dAtA[iNdEx]
2383                                 iNdEx++
2384                                 msglen |= (int(b) & 0x7F) << shift
2385                                 if b < 0x80 {
2386                                         break
2387                                 }
2388                         }
2389                         if msglen < 0 {
2390                                 return ErrInvalidLengthGenerated
2391                         }
2392                         postIndex := iNdEx + msglen
2393                         if postIndex > l {
2394                                 return io.ErrUnexpectedEOF
2395                         }
2396                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2397                                 return err
2398                         }
2399                         iNdEx = postIndex
2400                 case 2:
2401                         if wireType != 2 {
2402                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2403                         }
2404                         var msglen int
2405                         for shift := uint(0); ; shift += 7 {
2406                                 if shift >= 64 {
2407                                         return ErrIntOverflowGenerated
2408                                 }
2409                                 if iNdEx >= l {
2410                                         return io.ErrUnexpectedEOF
2411                                 }
2412                                 b := dAtA[iNdEx]
2413                                 iNdEx++
2414                                 msglen |= (int(b) & 0x7F) << shift
2415                                 if b < 0x80 {
2416                                         break
2417                                 }
2418                         }
2419                         if msglen < 0 {
2420                                 return ErrInvalidLengthGenerated
2421                         }
2422                         postIndex := iNdEx + msglen
2423                         if postIndex > l {
2424                                 return io.ErrUnexpectedEOF
2425                         }
2426                         m.Items = append(m.Items, Deployment{})
2427                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2428                                 return err
2429                         }
2430                         iNdEx = postIndex
2431                 default:
2432                         iNdEx = preIndex
2433                         skippy, err := skipGenerated(dAtA[iNdEx:])
2434                         if err != nil {
2435                                 return err
2436                         }
2437                         if skippy < 0 {
2438                                 return ErrInvalidLengthGenerated
2439                         }
2440                         if (iNdEx + skippy) > l {
2441                                 return io.ErrUnexpectedEOF
2442                         }
2443                         iNdEx += skippy
2444                 }
2445         }
2446
2447         if iNdEx > l {
2448                 return io.ErrUnexpectedEOF
2449         }
2450         return nil
2451 }
2452 func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
2453         l := len(dAtA)
2454         iNdEx := 0
2455         for iNdEx < l {
2456                 preIndex := iNdEx
2457                 var wire uint64
2458                 for shift := uint(0); ; shift += 7 {
2459                         if shift >= 64 {
2460                                 return ErrIntOverflowGenerated
2461                         }
2462                         if iNdEx >= l {
2463                                 return io.ErrUnexpectedEOF
2464                         }
2465                         b := dAtA[iNdEx]
2466                         iNdEx++
2467                         wire |= (uint64(b) & 0x7F) << shift
2468                         if b < 0x80 {
2469                                 break
2470                         }
2471                 }
2472                 fieldNum := int32(wire >> 3)
2473                 wireType := int(wire & 0x7)
2474                 if wireType == 4 {
2475                         return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
2476                 }
2477                 if fieldNum <= 0 {
2478                         return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
2479                 }
2480                 switch fieldNum {
2481                 case 1:
2482                         if wireType != 2 {
2483                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
2484                         }
2485                         var stringLen uint64
2486                         for shift := uint(0); ; shift += 7 {
2487                                 if shift >= 64 {
2488                                         return ErrIntOverflowGenerated
2489                                 }
2490                                 if iNdEx >= l {
2491                                         return io.ErrUnexpectedEOF
2492                                 }
2493                                 b := dAtA[iNdEx]
2494                                 iNdEx++
2495                                 stringLen |= (uint64(b) & 0x7F) << shift
2496                                 if b < 0x80 {
2497                                         break
2498                                 }
2499                         }
2500                         intStringLen := int(stringLen)
2501                         if intStringLen < 0 {
2502                                 return ErrInvalidLengthGenerated
2503                         }
2504                         postIndex := iNdEx + intStringLen
2505                         if postIndex > l {
2506                                 return io.ErrUnexpectedEOF
2507                         }
2508                         m.Name = string(dAtA[iNdEx:postIndex])
2509                         iNdEx = postIndex
2510                 case 2:
2511                         if wireType != 2 {
2512                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
2513                         }
2514                         var msglen int
2515                         for shift := uint(0); ; shift += 7 {
2516                                 if shift >= 64 {
2517                                         return ErrIntOverflowGenerated
2518                                 }
2519                                 if iNdEx >= l {
2520                                         return io.ErrUnexpectedEOF
2521                                 }
2522                                 b := dAtA[iNdEx]
2523                                 iNdEx++
2524                                 msglen |= (int(b) & 0x7F) << shift
2525                                 if b < 0x80 {
2526                                         break
2527                                 }
2528                         }
2529                         if msglen < 0 {
2530                                 return ErrInvalidLengthGenerated
2531                         }
2532                         postIndex := iNdEx + msglen
2533                         if postIndex > l {
2534                                 return io.ErrUnexpectedEOF
2535                         }
2536                         if m.UpdatedAnnotations == nil {
2537                                 m.UpdatedAnnotations = make(map[string]string)
2538                         }
2539                         var mapkey string
2540                         var mapvalue string
2541                         for iNdEx < postIndex {
2542                                 entryPreIndex := iNdEx
2543                                 var wire uint64
2544                                 for shift := uint(0); ; shift += 7 {
2545                                         if shift >= 64 {
2546                                                 return ErrIntOverflowGenerated
2547                                         }
2548                                         if iNdEx >= l {
2549                                                 return io.ErrUnexpectedEOF
2550                                         }
2551                                         b := dAtA[iNdEx]
2552                                         iNdEx++
2553                                         wire |= (uint64(b) & 0x7F) << shift
2554                                         if b < 0x80 {
2555                                                 break
2556                                         }
2557                                 }
2558                                 fieldNum := int32(wire >> 3)
2559                                 if fieldNum == 1 {
2560                                         var stringLenmapkey uint64
2561                                         for shift := uint(0); ; shift += 7 {
2562                                                 if shift >= 64 {
2563                                                         return ErrIntOverflowGenerated
2564                                                 }
2565                                                 if iNdEx >= l {
2566                                                         return io.ErrUnexpectedEOF
2567                                                 }
2568                                                 b := dAtA[iNdEx]
2569                                                 iNdEx++
2570                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
2571                                                 if b < 0x80 {
2572                                                         break
2573                                                 }
2574                                         }
2575                                         intStringLenmapkey := int(stringLenmapkey)
2576                                         if intStringLenmapkey < 0 {
2577                                                 return ErrInvalidLengthGenerated
2578                                         }
2579                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
2580                                         if postStringIndexmapkey > l {
2581                                                 return io.ErrUnexpectedEOF
2582                                         }
2583                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
2584                                         iNdEx = postStringIndexmapkey
2585                                 } else if fieldNum == 2 {
2586                                         var stringLenmapvalue uint64
2587                                         for shift := uint(0); ; shift += 7 {
2588                                                 if shift >= 64 {
2589                                                         return ErrIntOverflowGenerated
2590                                                 }
2591                                                 if iNdEx >= l {
2592                                                         return io.ErrUnexpectedEOF
2593                                                 }
2594                                                 b := dAtA[iNdEx]
2595                                                 iNdEx++
2596                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
2597                                                 if b < 0x80 {
2598                                                         break
2599                                                 }
2600                                         }
2601                                         intStringLenmapvalue := int(stringLenmapvalue)
2602                                         if intStringLenmapvalue < 0 {
2603                                                 return ErrInvalidLengthGenerated
2604                                         }
2605                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
2606                                         if postStringIndexmapvalue > l {
2607                                                 return io.ErrUnexpectedEOF
2608                                         }
2609                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
2610                                         iNdEx = postStringIndexmapvalue
2611                                 } else {
2612                                         iNdEx = entryPreIndex
2613                                         skippy, err := skipGenerated(dAtA[iNdEx:])
2614                                         if err != nil {
2615                                                 return err
2616                                         }
2617                                         if skippy < 0 {
2618                                                 return ErrInvalidLengthGenerated
2619                                         }
2620                                         if (iNdEx + skippy) > postIndex {
2621                                                 return io.ErrUnexpectedEOF
2622                                         }
2623                                         iNdEx += skippy
2624                                 }
2625                         }
2626                         m.UpdatedAnnotations[mapkey] = mapvalue
2627                         iNdEx = postIndex
2628                 case 3:
2629                         if wireType != 2 {
2630                                 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
2631                         }
2632                         var msglen int
2633                         for shift := uint(0); ; shift += 7 {
2634                                 if shift >= 64 {
2635                                         return ErrIntOverflowGenerated
2636                                 }
2637                                 if iNdEx >= l {
2638                                         return io.ErrUnexpectedEOF
2639                                 }
2640                                 b := dAtA[iNdEx]
2641                                 iNdEx++
2642                                 msglen |= (int(b) & 0x7F) << shift
2643                                 if b < 0x80 {
2644                                         break
2645                                 }
2646                         }
2647                         if msglen < 0 {
2648                                 return ErrInvalidLengthGenerated
2649                         }
2650                         postIndex := iNdEx + msglen
2651                         if postIndex > l {
2652                                 return io.ErrUnexpectedEOF
2653                         }
2654                         if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2655                                 return err
2656                         }
2657                         iNdEx = postIndex
2658                 default:
2659                         iNdEx = preIndex
2660                         skippy, err := skipGenerated(dAtA[iNdEx:])
2661                         if err != nil {
2662                                 return err
2663                         }
2664                         if skippy < 0 {
2665                                 return ErrInvalidLengthGenerated
2666                         }
2667                         if (iNdEx + skippy) > l {
2668                                 return io.ErrUnexpectedEOF
2669                         }
2670                         iNdEx += skippy
2671                 }
2672         }
2673
2674         if iNdEx > l {
2675                 return io.ErrUnexpectedEOF
2676         }
2677         return nil
2678 }
2679 func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
2680         l := len(dAtA)
2681         iNdEx := 0
2682         for iNdEx < l {
2683                 preIndex := iNdEx
2684                 var wire uint64
2685                 for shift := uint(0); ; shift += 7 {
2686                         if shift >= 64 {
2687                                 return ErrIntOverflowGenerated
2688                         }
2689                         if iNdEx >= l {
2690                                 return io.ErrUnexpectedEOF
2691                         }
2692                         b := dAtA[iNdEx]
2693                         iNdEx++
2694                         wire |= (uint64(b) & 0x7F) << shift
2695                         if b < 0x80 {
2696                                 break
2697                         }
2698                 }
2699                 fieldNum := int32(wire >> 3)
2700                 wireType := int(wire & 0x7)
2701                 if wireType == 4 {
2702                         return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
2703                 }
2704                 if fieldNum <= 0 {
2705                         return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2706                 }
2707                 switch fieldNum {
2708                 case 1:
2709                         if wireType != 0 {
2710                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
2711                         }
2712                         var v int32
2713                         for shift := uint(0); ; shift += 7 {
2714                                 if shift >= 64 {
2715                                         return ErrIntOverflowGenerated
2716                                 }
2717                                 if iNdEx >= l {
2718                                         return io.ErrUnexpectedEOF
2719                                 }
2720                                 b := dAtA[iNdEx]
2721                                 iNdEx++
2722                                 v |= (int32(b) & 0x7F) << shift
2723                                 if b < 0x80 {
2724                                         break
2725                                 }
2726                         }
2727                         m.Replicas = &v
2728                 case 2:
2729                         if wireType != 2 {
2730                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
2731                         }
2732                         var msglen int
2733                         for shift := uint(0); ; shift += 7 {
2734                                 if shift >= 64 {
2735                                         return ErrIntOverflowGenerated
2736                                 }
2737                                 if iNdEx >= l {
2738                                         return io.ErrUnexpectedEOF
2739                                 }
2740                                 b := dAtA[iNdEx]
2741                                 iNdEx++
2742                                 msglen |= (int(b) & 0x7F) << shift
2743                                 if b < 0x80 {
2744                                         break
2745                                 }
2746                         }
2747                         if msglen < 0 {
2748                                 return ErrInvalidLengthGenerated
2749                         }
2750                         postIndex := iNdEx + msglen
2751                         if postIndex > l {
2752                                 return io.ErrUnexpectedEOF
2753                         }
2754                         if m.Selector == nil {
2755                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
2756                         }
2757                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2758                                 return err
2759                         }
2760                         iNdEx = postIndex
2761                 case 3:
2762                         if wireType != 2 {
2763                                 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
2764                         }
2765                         var msglen int
2766                         for shift := uint(0); ; shift += 7 {
2767                                 if shift >= 64 {
2768                                         return ErrIntOverflowGenerated
2769                                 }
2770                                 if iNdEx >= l {
2771                                         return io.ErrUnexpectedEOF
2772                                 }
2773                                 b := dAtA[iNdEx]
2774                                 iNdEx++
2775                                 msglen |= (int(b) & 0x7F) << shift
2776                                 if b < 0x80 {
2777                                         break
2778                                 }
2779                         }
2780                         if msglen < 0 {
2781                                 return ErrInvalidLengthGenerated
2782                         }
2783                         postIndex := iNdEx + msglen
2784                         if postIndex > l {
2785                                 return io.ErrUnexpectedEOF
2786                         }
2787                         if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2788                                 return err
2789                         }
2790                         iNdEx = postIndex
2791                 case 4:
2792                         if wireType != 2 {
2793                                 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
2794                         }
2795                         var msglen int
2796                         for shift := uint(0); ; shift += 7 {
2797                                 if shift >= 64 {
2798                                         return ErrIntOverflowGenerated
2799                                 }
2800                                 if iNdEx >= l {
2801                                         return io.ErrUnexpectedEOF
2802                                 }
2803                                 b := dAtA[iNdEx]
2804                                 iNdEx++
2805                                 msglen |= (int(b) & 0x7F) << shift
2806                                 if b < 0x80 {
2807                                         break
2808                                 }
2809                         }
2810                         if msglen < 0 {
2811                                 return ErrInvalidLengthGenerated
2812                         }
2813                         postIndex := iNdEx + msglen
2814                         if postIndex > l {
2815                                 return io.ErrUnexpectedEOF
2816                         }
2817                         if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2818                                 return err
2819                         }
2820                         iNdEx = postIndex
2821                 case 5:
2822                         if wireType != 0 {
2823                                 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
2824                         }
2825                         m.MinReadySeconds = 0
2826                         for shift := uint(0); ; shift += 7 {
2827                                 if shift >= 64 {
2828                                         return ErrIntOverflowGenerated
2829                                 }
2830                                 if iNdEx >= l {
2831                                         return io.ErrUnexpectedEOF
2832                                 }
2833                                 b := dAtA[iNdEx]
2834                                 iNdEx++
2835                                 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
2836                                 if b < 0x80 {
2837                                         break
2838                                 }
2839                         }
2840                 case 6:
2841                         if wireType != 0 {
2842                                 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
2843                         }
2844                         var v int32
2845                         for shift := uint(0); ; shift += 7 {
2846                                 if shift >= 64 {
2847                                         return ErrIntOverflowGenerated
2848                                 }
2849                                 if iNdEx >= l {
2850                                         return io.ErrUnexpectedEOF
2851                                 }
2852                                 b := dAtA[iNdEx]
2853                                 iNdEx++
2854                                 v |= (int32(b) & 0x7F) << shift
2855                                 if b < 0x80 {
2856                                         break
2857                                 }
2858                         }
2859                         m.RevisionHistoryLimit = &v
2860                 case 7:
2861                         if wireType != 0 {
2862                                 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
2863                         }
2864                         var v int
2865                         for shift := uint(0); ; shift += 7 {
2866                                 if shift >= 64 {
2867                                         return ErrIntOverflowGenerated
2868                                 }
2869                                 if iNdEx >= l {
2870                                         return io.ErrUnexpectedEOF
2871                                 }
2872                                 b := dAtA[iNdEx]
2873                                 iNdEx++
2874                                 v |= (int(b) & 0x7F) << shift
2875                                 if b < 0x80 {
2876                                         break
2877                                 }
2878                         }
2879                         m.Paused = bool(v != 0)
2880                 case 8:
2881                         if wireType != 2 {
2882                                 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
2883                         }
2884                         var msglen int
2885                         for shift := uint(0); ; shift += 7 {
2886                                 if shift >= 64 {
2887                                         return ErrIntOverflowGenerated
2888                                 }
2889                                 if iNdEx >= l {
2890                                         return io.ErrUnexpectedEOF
2891                                 }
2892                                 b := dAtA[iNdEx]
2893                                 iNdEx++
2894                                 msglen |= (int(b) & 0x7F) << shift
2895                                 if b < 0x80 {
2896                                         break
2897                                 }
2898                         }
2899                         if msglen < 0 {
2900                                 return ErrInvalidLengthGenerated
2901                         }
2902                         postIndex := iNdEx + msglen
2903                         if postIndex > l {
2904                                 return io.ErrUnexpectedEOF
2905                         }
2906                         if m.RollbackTo == nil {
2907                                 m.RollbackTo = &RollbackConfig{}
2908                         }
2909                         if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2910                                 return err
2911                         }
2912                         iNdEx = postIndex
2913                 case 9:
2914                         if wireType != 0 {
2915                                 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
2916                         }
2917                         var v int32
2918                         for shift := uint(0); ; shift += 7 {
2919                                 if shift >= 64 {
2920                                         return ErrIntOverflowGenerated
2921                                 }
2922                                 if iNdEx >= l {
2923                                         return io.ErrUnexpectedEOF
2924                                 }
2925                                 b := dAtA[iNdEx]
2926                                 iNdEx++
2927                                 v |= (int32(b) & 0x7F) << shift
2928                                 if b < 0x80 {
2929                                         break
2930                                 }
2931                         }
2932                         m.ProgressDeadlineSeconds = &v
2933                 default:
2934                         iNdEx = preIndex
2935                         skippy, err := skipGenerated(dAtA[iNdEx:])
2936                         if err != nil {
2937                                 return err
2938                         }
2939                         if skippy < 0 {
2940                                 return ErrInvalidLengthGenerated
2941                         }
2942                         if (iNdEx + skippy) > l {
2943                                 return io.ErrUnexpectedEOF
2944                         }
2945                         iNdEx += skippy
2946                 }
2947         }
2948
2949         if iNdEx > l {
2950                 return io.ErrUnexpectedEOF
2951         }
2952         return nil
2953 }
2954 func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
2955         l := len(dAtA)
2956         iNdEx := 0
2957         for iNdEx < l {
2958                 preIndex := iNdEx
2959                 var wire uint64
2960                 for shift := uint(0); ; shift += 7 {
2961                         if shift >= 64 {
2962                                 return ErrIntOverflowGenerated
2963                         }
2964                         if iNdEx >= l {
2965                                 return io.ErrUnexpectedEOF
2966                         }
2967                         b := dAtA[iNdEx]
2968                         iNdEx++
2969                         wire |= (uint64(b) & 0x7F) << shift
2970                         if b < 0x80 {
2971                                 break
2972                         }
2973                 }
2974                 fieldNum := int32(wire >> 3)
2975                 wireType := int(wire & 0x7)
2976                 if wireType == 4 {
2977                         return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
2978                 }
2979                 if fieldNum <= 0 {
2980                         return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
2981                 }
2982                 switch fieldNum {
2983                 case 1:
2984                         if wireType != 0 {
2985                                 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
2986                         }
2987                         m.ObservedGeneration = 0
2988                         for shift := uint(0); ; shift += 7 {
2989                                 if shift >= 64 {
2990                                         return ErrIntOverflowGenerated
2991                                 }
2992                                 if iNdEx >= l {
2993                                         return io.ErrUnexpectedEOF
2994                                 }
2995                                 b := dAtA[iNdEx]
2996                                 iNdEx++
2997                                 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
2998                                 if b < 0x80 {
2999                                         break
3000                                 }
3001                         }
3002                 case 2:
3003                         if wireType != 0 {
3004                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
3005                         }
3006                         m.Replicas = 0
3007                         for shift := uint(0); ; shift += 7 {
3008                                 if shift >= 64 {
3009                                         return ErrIntOverflowGenerated
3010                                 }
3011                                 if iNdEx >= l {
3012                                         return io.ErrUnexpectedEOF
3013                                 }
3014                                 b := dAtA[iNdEx]
3015                                 iNdEx++
3016                                 m.Replicas |= (int32(b) & 0x7F) << shift
3017                                 if b < 0x80 {
3018                                         break
3019                                 }
3020                         }
3021                 case 3:
3022                         if wireType != 0 {
3023                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
3024                         }
3025                         m.UpdatedReplicas = 0
3026                         for shift := uint(0); ; shift += 7 {
3027                                 if shift >= 64 {
3028                                         return ErrIntOverflowGenerated
3029                                 }
3030                                 if iNdEx >= l {
3031                                         return io.ErrUnexpectedEOF
3032                                 }
3033                                 b := dAtA[iNdEx]
3034                                 iNdEx++
3035                                 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
3036                                 if b < 0x80 {
3037                                         break
3038                                 }
3039                         }
3040                 case 4:
3041                         if wireType != 0 {
3042                                 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
3043                         }
3044                         m.AvailableReplicas = 0
3045                         for shift := uint(0); ; shift += 7 {
3046                                 if shift >= 64 {
3047                                         return ErrIntOverflowGenerated
3048                                 }
3049                                 if iNdEx >= l {
3050                                         return io.ErrUnexpectedEOF
3051                                 }
3052                                 b := dAtA[iNdEx]
3053                                 iNdEx++
3054                                 m.AvailableReplicas |= (int32(b) & 0x7F) << shift
3055                                 if b < 0x80 {
3056                                         break
3057                                 }
3058                         }
3059                 case 5:
3060                         if wireType != 0 {
3061                                 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
3062                         }
3063                         m.UnavailableReplicas = 0
3064                         for shift := uint(0); ; shift += 7 {
3065                                 if shift >= 64 {
3066                                         return ErrIntOverflowGenerated
3067                                 }
3068                                 if iNdEx >= l {
3069                                         return io.ErrUnexpectedEOF
3070                                 }
3071                                 b := dAtA[iNdEx]
3072                                 iNdEx++
3073                                 m.UnavailableReplicas |= (int32(b) & 0x7F) << shift
3074                                 if b < 0x80 {
3075                                         break
3076                                 }
3077                         }
3078                 case 6:
3079                         if wireType != 2 {
3080                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
3081                         }
3082                         var msglen int
3083                         for shift := uint(0); ; shift += 7 {
3084                                 if shift >= 64 {
3085                                         return ErrIntOverflowGenerated
3086                                 }
3087                                 if iNdEx >= l {
3088                                         return io.ErrUnexpectedEOF
3089                                 }
3090                                 b := dAtA[iNdEx]
3091                                 iNdEx++
3092                                 msglen |= (int(b) & 0x7F) << shift
3093                                 if b < 0x80 {
3094                                         break
3095                                 }
3096                         }
3097                         if msglen < 0 {
3098                                 return ErrInvalidLengthGenerated
3099                         }
3100                         postIndex := iNdEx + msglen
3101                         if postIndex > l {
3102                                 return io.ErrUnexpectedEOF
3103                         }
3104                         m.Conditions = append(m.Conditions, DeploymentCondition{})
3105                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3106                                 return err
3107                         }
3108                         iNdEx = postIndex
3109                 case 7:
3110                         if wireType != 0 {
3111                                 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
3112                         }
3113                         m.ReadyReplicas = 0
3114                         for shift := uint(0); ; shift += 7 {
3115                                 if shift >= 64 {
3116                                         return ErrIntOverflowGenerated
3117                                 }
3118                                 if iNdEx >= l {
3119                                         return io.ErrUnexpectedEOF
3120                                 }
3121                                 b := dAtA[iNdEx]
3122                                 iNdEx++
3123                                 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
3124                                 if b < 0x80 {
3125                                         break
3126                                 }
3127                         }
3128                 case 8:
3129                         if wireType != 0 {
3130                                 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
3131                         }
3132                         var v int32
3133                         for shift := uint(0); ; shift += 7 {
3134                                 if shift >= 64 {
3135                                         return ErrIntOverflowGenerated
3136                                 }
3137                                 if iNdEx >= l {
3138                                         return io.ErrUnexpectedEOF
3139                                 }
3140                                 b := dAtA[iNdEx]
3141                                 iNdEx++
3142                                 v |= (int32(b) & 0x7F) << shift
3143                                 if b < 0x80 {
3144                                         break
3145                                 }
3146                         }
3147                         m.CollisionCount = &v
3148                 default:
3149                         iNdEx = preIndex
3150                         skippy, err := skipGenerated(dAtA[iNdEx:])
3151                         if err != nil {
3152                                 return err
3153                         }
3154                         if skippy < 0 {
3155                                 return ErrInvalidLengthGenerated
3156                         }
3157                         if (iNdEx + skippy) > l {
3158                                 return io.ErrUnexpectedEOF
3159                         }
3160                         iNdEx += skippy
3161                 }
3162         }
3163
3164         if iNdEx > l {
3165                 return io.ErrUnexpectedEOF
3166         }
3167         return nil
3168 }
3169 func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
3170         l := len(dAtA)
3171         iNdEx := 0
3172         for iNdEx < l {
3173                 preIndex := iNdEx
3174                 var wire uint64
3175                 for shift := uint(0); ; shift += 7 {
3176                         if shift >= 64 {
3177                                 return ErrIntOverflowGenerated
3178                         }
3179                         if iNdEx >= l {
3180                                 return io.ErrUnexpectedEOF
3181                         }
3182                         b := dAtA[iNdEx]
3183                         iNdEx++
3184                         wire |= (uint64(b) & 0x7F) << shift
3185                         if b < 0x80 {
3186                                 break
3187                         }
3188                 }
3189                 fieldNum := int32(wire >> 3)
3190                 wireType := int(wire & 0x7)
3191                 if wireType == 4 {
3192                         return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
3193                 }
3194                 if fieldNum <= 0 {
3195                         return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
3196                 }
3197                 switch fieldNum {
3198                 case 1:
3199                         if wireType != 2 {
3200                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3201                         }
3202                         var stringLen uint64
3203                         for shift := uint(0); ; shift += 7 {
3204                                 if shift >= 64 {
3205                                         return ErrIntOverflowGenerated
3206                                 }
3207                                 if iNdEx >= l {
3208                                         return io.ErrUnexpectedEOF
3209                                 }
3210                                 b := dAtA[iNdEx]
3211                                 iNdEx++
3212                                 stringLen |= (uint64(b) & 0x7F) << shift
3213                                 if b < 0x80 {
3214                                         break
3215                                 }
3216                         }
3217                         intStringLen := int(stringLen)
3218                         if intStringLen < 0 {
3219                                 return ErrInvalidLengthGenerated
3220                         }
3221                         postIndex := iNdEx + intStringLen
3222                         if postIndex > l {
3223                                 return io.ErrUnexpectedEOF
3224                         }
3225                         m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
3226                         iNdEx = postIndex
3227                 case 2:
3228                         if wireType != 2 {
3229                                 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
3230                         }
3231                         var msglen int
3232                         for shift := uint(0); ; shift += 7 {
3233                                 if shift >= 64 {
3234                                         return ErrIntOverflowGenerated
3235                                 }
3236                                 if iNdEx >= l {
3237                                         return io.ErrUnexpectedEOF
3238                                 }
3239                                 b := dAtA[iNdEx]
3240                                 iNdEx++
3241                                 msglen |= (int(b) & 0x7F) << shift
3242                                 if b < 0x80 {
3243                                         break
3244                                 }
3245                         }
3246                         if msglen < 0 {
3247                                 return ErrInvalidLengthGenerated
3248                         }
3249                         postIndex := iNdEx + msglen
3250                         if postIndex > l {
3251                                 return io.ErrUnexpectedEOF
3252                         }
3253                         if m.RollingUpdate == nil {
3254                                 m.RollingUpdate = &RollingUpdateDeployment{}
3255                         }
3256                         if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3257                                 return err
3258                         }
3259                         iNdEx = postIndex
3260                 default:
3261                         iNdEx = preIndex
3262                         skippy, err := skipGenerated(dAtA[iNdEx:])
3263                         if err != nil {
3264                                 return err
3265                         }
3266                         if skippy < 0 {
3267                                 return ErrInvalidLengthGenerated
3268                         }
3269                         if (iNdEx + skippy) > l {
3270                                 return io.ErrUnexpectedEOF
3271                         }
3272                         iNdEx += skippy
3273                 }
3274         }
3275
3276         if iNdEx > l {
3277                 return io.ErrUnexpectedEOF
3278         }
3279         return nil
3280 }
3281 func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
3282         l := len(dAtA)
3283         iNdEx := 0
3284         for iNdEx < l {
3285                 preIndex := iNdEx
3286                 var wire uint64
3287                 for shift := uint(0); ; shift += 7 {
3288                         if shift >= 64 {
3289                                 return ErrIntOverflowGenerated
3290                         }
3291                         if iNdEx >= l {
3292                                 return io.ErrUnexpectedEOF
3293                         }
3294                         b := dAtA[iNdEx]
3295                         iNdEx++
3296                         wire |= (uint64(b) & 0x7F) << shift
3297                         if b < 0x80 {
3298                                 break
3299                         }
3300                 }
3301                 fieldNum := int32(wire >> 3)
3302                 wireType := int(wire & 0x7)
3303                 if wireType == 4 {
3304                         return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
3305                 }
3306                 if fieldNum <= 0 {
3307                         return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
3308                 }
3309                 switch fieldNum {
3310                 case 1:
3311                         if wireType != 0 {
3312                                 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
3313                         }
3314                         m.Revision = 0
3315                         for shift := uint(0); ; shift += 7 {
3316                                 if shift >= 64 {
3317                                         return ErrIntOverflowGenerated
3318                                 }
3319                                 if iNdEx >= l {
3320                                         return io.ErrUnexpectedEOF
3321                                 }
3322                                 b := dAtA[iNdEx]
3323                                 iNdEx++
3324                                 m.Revision |= (int64(b) & 0x7F) << shift
3325                                 if b < 0x80 {
3326                                         break
3327                                 }
3328                         }
3329                 default:
3330                         iNdEx = preIndex
3331                         skippy, err := skipGenerated(dAtA[iNdEx:])
3332                         if err != nil {
3333                                 return err
3334                         }
3335                         if skippy < 0 {
3336                                 return ErrInvalidLengthGenerated
3337                         }
3338                         if (iNdEx + skippy) > l {
3339                                 return io.ErrUnexpectedEOF
3340                         }
3341                         iNdEx += skippy
3342                 }
3343         }
3344
3345         if iNdEx > l {
3346                 return io.ErrUnexpectedEOF
3347         }
3348         return nil
3349 }
3350 func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
3351         l := len(dAtA)
3352         iNdEx := 0
3353         for iNdEx < l {
3354                 preIndex := iNdEx
3355                 var wire uint64
3356                 for shift := uint(0); ; shift += 7 {
3357                         if shift >= 64 {
3358                                 return ErrIntOverflowGenerated
3359                         }
3360                         if iNdEx >= l {
3361                                 return io.ErrUnexpectedEOF
3362                         }
3363                         b := dAtA[iNdEx]
3364                         iNdEx++
3365                         wire |= (uint64(b) & 0x7F) << shift
3366                         if b < 0x80 {
3367                                 break
3368                         }
3369                 }
3370                 fieldNum := int32(wire >> 3)
3371                 wireType := int(wire & 0x7)
3372                 if wireType == 4 {
3373                         return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
3374                 }
3375                 if fieldNum <= 0 {
3376                         return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
3377                 }
3378                 switch fieldNum {
3379                 case 1:
3380                         if wireType != 2 {
3381                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
3382                         }
3383                         var msglen int
3384                         for shift := uint(0); ; shift += 7 {
3385                                 if shift >= 64 {
3386                                         return ErrIntOverflowGenerated
3387                                 }
3388                                 if iNdEx >= l {
3389                                         return io.ErrUnexpectedEOF
3390                                 }
3391                                 b := dAtA[iNdEx]
3392                                 iNdEx++
3393                                 msglen |= (int(b) & 0x7F) << shift
3394                                 if b < 0x80 {
3395                                         break
3396                                 }
3397                         }
3398                         if msglen < 0 {
3399                                 return ErrInvalidLengthGenerated
3400                         }
3401                         postIndex := iNdEx + msglen
3402                         if postIndex > l {
3403                                 return io.ErrUnexpectedEOF
3404                         }
3405                         if m.MaxUnavailable == nil {
3406                                 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
3407                         }
3408                         if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3409                                 return err
3410                         }
3411                         iNdEx = postIndex
3412                 case 2:
3413                         if wireType != 2 {
3414                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
3415                         }
3416                         var msglen int
3417                         for shift := uint(0); ; shift += 7 {
3418                                 if shift >= 64 {
3419                                         return ErrIntOverflowGenerated
3420                                 }
3421                                 if iNdEx >= l {
3422                                         return io.ErrUnexpectedEOF
3423                                 }
3424                                 b := dAtA[iNdEx]
3425                                 iNdEx++
3426                                 msglen |= (int(b) & 0x7F) << shift
3427                                 if b < 0x80 {
3428                                         break
3429                                 }
3430                         }
3431                         if msglen < 0 {
3432                                 return ErrInvalidLengthGenerated
3433                         }
3434                         postIndex := iNdEx + msglen
3435                         if postIndex > l {
3436                                 return io.ErrUnexpectedEOF
3437                         }
3438                         if m.MaxSurge == nil {
3439                                 m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
3440                         }
3441                         if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3442                                 return err
3443                         }
3444                         iNdEx = postIndex
3445                 default:
3446                         iNdEx = preIndex
3447                         skippy, err := skipGenerated(dAtA[iNdEx:])
3448                         if err != nil {
3449                                 return err
3450                         }
3451                         if skippy < 0 {
3452                                 return ErrInvalidLengthGenerated
3453                         }
3454                         if (iNdEx + skippy) > l {
3455                                 return io.ErrUnexpectedEOF
3456                         }
3457                         iNdEx += skippy
3458                 }
3459         }
3460
3461         if iNdEx > l {
3462                 return io.ErrUnexpectedEOF
3463         }
3464         return nil
3465 }
3466 func (m *RollingUpdateStatefulSetStrategy) Unmarshal(dAtA []byte) error {
3467         l := len(dAtA)
3468         iNdEx := 0
3469         for iNdEx < l {
3470                 preIndex := iNdEx
3471                 var wire uint64
3472                 for shift := uint(0); ; shift += 7 {
3473                         if shift >= 64 {
3474                                 return ErrIntOverflowGenerated
3475                         }
3476                         if iNdEx >= l {
3477                                 return io.ErrUnexpectedEOF
3478                         }
3479                         b := dAtA[iNdEx]
3480                         iNdEx++
3481                         wire |= (uint64(b) & 0x7F) << shift
3482                         if b < 0x80 {
3483                                 break
3484                         }
3485                 }
3486                 fieldNum := int32(wire >> 3)
3487                 wireType := int(wire & 0x7)
3488                 if wireType == 4 {
3489                         return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: wiretype end group for non-group")
3490                 }
3491                 if fieldNum <= 0 {
3492                         return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
3493                 }
3494                 switch fieldNum {
3495                 case 1:
3496                         if wireType != 0 {
3497                                 return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
3498                         }
3499                         var v int32
3500                         for shift := uint(0); ; shift += 7 {
3501                                 if shift >= 64 {
3502                                         return ErrIntOverflowGenerated
3503                                 }
3504                                 if iNdEx >= l {
3505                                         return io.ErrUnexpectedEOF
3506                                 }
3507                                 b := dAtA[iNdEx]
3508                                 iNdEx++
3509                                 v |= (int32(b) & 0x7F) << shift
3510                                 if b < 0x80 {
3511                                         break
3512                                 }
3513                         }
3514                         m.Partition = &v
3515                 default:
3516                         iNdEx = preIndex
3517                         skippy, err := skipGenerated(dAtA[iNdEx:])
3518                         if err != nil {
3519                                 return err
3520                         }
3521                         if skippy < 0 {
3522                                 return ErrInvalidLengthGenerated
3523                         }
3524                         if (iNdEx + skippy) > l {
3525                                 return io.ErrUnexpectedEOF
3526                         }
3527                         iNdEx += skippy
3528                 }
3529         }
3530
3531         if iNdEx > l {
3532                 return io.ErrUnexpectedEOF
3533         }
3534         return nil
3535 }
3536 func (m *Scale) Unmarshal(dAtA []byte) error {
3537         l := len(dAtA)
3538         iNdEx := 0
3539         for iNdEx < l {
3540                 preIndex := iNdEx
3541                 var wire uint64
3542                 for shift := uint(0); ; shift += 7 {
3543                         if shift >= 64 {
3544                                 return ErrIntOverflowGenerated
3545                         }
3546                         if iNdEx >= l {
3547                                 return io.ErrUnexpectedEOF
3548                         }
3549                         b := dAtA[iNdEx]
3550                         iNdEx++
3551                         wire |= (uint64(b) & 0x7F) << shift
3552                         if b < 0x80 {
3553                                 break
3554                         }
3555                 }
3556                 fieldNum := int32(wire >> 3)
3557                 wireType := int(wire & 0x7)
3558                 if wireType == 4 {
3559                         return fmt.Errorf("proto: Scale: wiretype end group for non-group")
3560                 }
3561                 if fieldNum <= 0 {
3562                         return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
3563                 }
3564                 switch fieldNum {
3565                 case 1:
3566                         if wireType != 2 {
3567                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3568                         }
3569                         var msglen int
3570                         for shift := uint(0); ; shift += 7 {
3571                                 if shift >= 64 {
3572                                         return ErrIntOverflowGenerated
3573                                 }
3574                                 if iNdEx >= l {
3575                                         return io.ErrUnexpectedEOF
3576                                 }
3577                                 b := dAtA[iNdEx]
3578                                 iNdEx++
3579                                 msglen |= (int(b) & 0x7F) << shift
3580                                 if b < 0x80 {
3581                                         break
3582                                 }
3583                         }
3584                         if msglen < 0 {
3585                                 return ErrInvalidLengthGenerated
3586                         }
3587                         postIndex := iNdEx + msglen
3588                         if postIndex > l {
3589                                 return io.ErrUnexpectedEOF
3590                         }
3591                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3592                                 return err
3593                         }
3594                         iNdEx = postIndex
3595                 case 2:
3596                         if wireType != 2 {
3597                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3598                         }
3599                         var msglen int
3600                         for shift := uint(0); ; shift += 7 {
3601                                 if shift >= 64 {
3602                                         return ErrIntOverflowGenerated
3603                                 }
3604                                 if iNdEx >= l {
3605                                         return io.ErrUnexpectedEOF
3606                                 }
3607                                 b := dAtA[iNdEx]
3608                                 iNdEx++
3609                                 msglen |= (int(b) & 0x7F) << shift
3610                                 if b < 0x80 {
3611                                         break
3612                                 }
3613                         }
3614                         if msglen < 0 {
3615                                 return ErrInvalidLengthGenerated
3616                         }
3617                         postIndex := iNdEx + msglen
3618                         if postIndex > l {
3619                                 return io.ErrUnexpectedEOF
3620                         }
3621                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3622                                 return err
3623                         }
3624                         iNdEx = postIndex
3625                 case 3:
3626                         if wireType != 2 {
3627                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3628                         }
3629                         var msglen int
3630                         for shift := uint(0); ; shift += 7 {
3631                                 if shift >= 64 {
3632                                         return ErrIntOverflowGenerated
3633                                 }
3634                                 if iNdEx >= l {
3635                                         return io.ErrUnexpectedEOF
3636                                 }
3637                                 b := dAtA[iNdEx]
3638                                 iNdEx++
3639                                 msglen |= (int(b) & 0x7F) << shift
3640                                 if b < 0x80 {
3641                                         break
3642                                 }
3643                         }
3644                         if msglen < 0 {
3645                                 return ErrInvalidLengthGenerated
3646                         }
3647                         postIndex := iNdEx + msglen
3648                         if postIndex > l {
3649                                 return io.ErrUnexpectedEOF
3650                         }
3651                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3652                                 return err
3653                         }
3654                         iNdEx = postIndex
3655                 default:
3656                         iNdEx = preIndex
3657                         skippy, err := skipGenerated(dAtA[iNdEx:])
3658                         if err != nil {
3659                                 return err
3660                         }
3661                         if skippy < 0 {
3662                                 return ErrInvalidLengthGenerated
3663                         }
3664                         if (iNdEx + skippy) > l {
3665                                 return io.ErrUnexpectedEOF
3666                         }
3667                         iNdEx += skippy
3668                 }
3669         }
3670
3671         if iNdEx > l {
3672                 return io.ErrUnexpectedEOF
3673         }
3674         return nil
3675 }
3676 func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
3677         l := len(dAtA)
3678         iNdEx := 0
3679         for iNdEx < l {
3680                 preIndex := iNdEx
3681                 var wire uint64
3682                 for shift := uint(0); ; shift += 7 {
3683                         if shift >= 64 {
3684                                 return ErrIntOverflowGenerated
3685                         }
3686                         if iNdEx >= l {
3687                                 return io.ErrUnexpectedEOF
3688                         }
3689                         b := dAtA[iNdEx]
3690                         iNdEx++
3691                         wire |= (uint64(b) & 0x7F) << shift
3692                         if b < 0x80 {
3693                                 break
3694                         }
3695                 }
3696                 fieldNum := int32(wire >> 3)
3697                 wireType := int(wire & 0x7)
3698                 if wireType == 4 {
3699                         return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
3700                 }
3701                 if fieldNum <= 0 {
3702                         return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3703                 }
3704                 switch fieldNum {
3705                 case 1:
3706                         if wireType != 0 {
3707                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
3708                         }
3709                         m.Replicas = 0
3710                         for shift := uint(0); ; shift += 7 {
3711                                 if shift >= 64 {
3712                                         return ErrIntOverflowGenerated
3713                                 }
3714                                 if iNdEx >= l {
3715                                         return io.ErrUnexpectedEOF
3716                                 }
3717                                 b := dAtA[iNdEx]
3718                                 iNdEx++
3719                                 m.Replicas |= (int32(b) & 0x7F) << shift
3720                                 if b < 0x80 {
3721                                         break
3722                                 }
3723                         }
3724                 default:
3725                         iNdEx = preIndex
3726                         skippy, err := skipGenerated(dAtA[iNdEx:])
3727                         if err != nil {
3728                                 return err
3729                         }
3730                         if skippy < 0 {
3731                                 return ErrInvalidLengthGenerated
3732                         }
3733                         if (iNdEx + skippy) > l {
3734                                 return io.ErrUnexpectedEOF
3735                         }
3736                         iNdEx += skippy
3737                 }
3738         }
3739
3740         if iNdEx > l {
3741                 return io.ErrUnexpectedEOF
3742         }
3743         return nil
3744 }
3745 func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
3746         l := len(dAtA)
3747         iNdEx := 0
3748         for iNdEx < l {
3749                 preIndex := iNdEx
3750                 var wire uint64
3751                 for shift := uint(0); ; shift += 7 {
3752                         if shift >= 64 {
3753                                 return ErrIntOverflowGenerated
3754                         }
3755                         if iNdEx >= l {
3756                                 return io.ErrUnexpectedEOF
3757                         }
3758                         b := dAtA[iNdEx]
3759                         iNdEx++
3760                         wire |= (uint64(b) & 0x7F) << shift
3761                         if b < 0x80 {
3762                                 break
3763                         }
3764                 }
3765                 fieldNum := int32(wire >> 3)
3766                 wireType := int(wire & 0x7)
3767                 if wireType == 4 {
3768                         return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
3769                 }
3770                 if fieldNum <= 0 {
3771                         return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3772                 }
3773                 switch fieldNum {
3774                 case 1:
3775                         if wireType != 0 {
3776                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
3777                         }
3778                         m.Replicas = 0
3779                         for shift := uint(0); ; shift += 7 {
3780                                 if shift >= 64 {
3781                                         return ErrIntOverflowGenerated
3782                                 }
3783                                 if iNdEx >= l {
3784                                         return io.ErrUnexpectedEOF
3785                                 }
3786                                 b := dAtA[iNdEx]
3787                                 iNdEx++
3788                                 m.Replicas |= (int32(b) & 0x7F) << shift
3789                                 if b < 0x80 {
3790                                         break
3791                                 }
3792                         }
3793                 case 2:
3794                         if wireType != 2 {
3795                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
3796                         }
3797                         var msglen int
3798                         for shift := uint(0); ; shift += 7 {
3799                                 if shift >= 64 {
3800                                         return ErrIntOverflowGenerated
3801                                 }
3802                                 if iNdEx >= l {
3803                                         return io.ErrUnexpectedEOF
3804                                 }
3805                                 b := dAtA[iNdEx]
3806                                 iNdEx++
3807                                 msglen |= (int(b) & 0x7F) << shift
3808                                 if b < 0x80 {
3809                                         break
3810                                 }
3811                         }
3812                         if msglen < 0 {
3813                                 return ErrInvalidLengthGenerated
3814                         }
3815                         postIndex := iNdEx + msglen
3816                         if postIndex > l {
3817                                 return io.ErrUnexpectedEOF
3818                         }
3819                         if m.Selector == nil {
3820                                 m.Selector = make(map[string]string)
3821                         }
3822                         var mapkey string
3823                         var mapvalue string
3824                         for iNdEx < postIndex {
3825                                 entryPreIndex := iNdEx
3826                                 var wire uint64
3827                                 for shift := uint(0); ; shift += 7 {
3828                                         if shift >= 64 {
3829                                                 return ErrIntOverflowGenerated
3830                                         }
3831                                         if iNdEx >= l {
3832                                                 return io.ErrUnexpectedEOF
3833                                         }
3834                                         b := dAtA[iNdEx]
3835                                         iNdEx++
3836                                         wire |= (uint64(b) & 0x7F) << shift
3837                                         if b < 0x80 {
3838                                                 break
3839                                         }
3840                                 }
3841                                 fieldNum := int32(wire >> 3)
3842                                 if fieldNum == 1 {
3843                                         var stringLenmapkey uint64
3844                                         for shift := uint(0); ; shift += 7 {
3845                                                 if shift >= 64 {
3846                                                         return ErrIntOverflowGenerated
3847                                                 }
3848                                                 if iNdEx >= l {
3849                                                         return io.ErrUnexpectedEOF
3850                                                 }
3851                                                 b := dAtA[iNdEx]
3852                                                 iNdEx++
3853                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
3854                                                 if b < 0x80 {
3855                                                         break
3856                                                 }
3857                                         }
3858                                         intStringLenmapkey := int(stringLenmapkey)
3859                                         if intStringLenmapkey < 0 {
3860                                                 return ErrInvalidLengthGenerated
3861                                         }
3862                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
3863                                         if postStringIndexmapkey > l {
3864                                                 return io.ErrUnexpectedEOF
3865                                         }
3866                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
3867                                         iNdEx = postStringIndexmapkey
3868                                 } else if fieldNum == 2 {
3869                                         var stringLenmapvalue uint64
3870                                         for shift := uint(0); ; shift += 7 {
3871                                                 if shift >= 64 {
3872                                                         return ErrIntOverflowGenerated
3873                                                 }
3874                                                 if iNdEx >= l {
3875                                                         return io.ErrUnexpectedEOF
3876                                                 }
3877                                                 b := dAtA[iNdEx]
3878                                                 iNdEx++
3879                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
3880                                                 if b < 0x80 {
3881                                                         break
3882                                                 }
3883                                         }
3884                                         intStringLenmapvalue := int(stringLenmapvalue)
3885                                         if intStringLenmapvalue < 0 {
3886                                                 return ErrInvalidLengthGenerated
3887                                         }
3888                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
3889                                         if postStringIndexmapvalue > l {
3890                                                 return io.ErrUnexpectedEOF
3891                                         }
3892                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
3893                                         iNdEx = postStringIndexmapvalue
3894                                 } else {
3895                                         iNdEx = entryPreIndex
3896                                         skippy, err := skipGenerated(dAtA[iNdEx:])
3897                                         if err != nil {
3898                                                 return err
3899                                         }
3900                                         if skippy < 0 {
3901                                                 return ErrInvalidLengthGenerated
3902                                         }
3903                                         if (iNdEx + skippy) > postIndex {
3904                                                 return io.ErrUnexpectedEOF
3905                                         }
3906                                         iNdEx += skippy
3907                                 }
3908                         }
3909                         m.Selector[mapkey] = mapvalue
3910                         iNdEx = postIndex
3911                 case 3:
3912                         if wireType != 2 {
3913                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
3914                         }
3915                         var stringLen uint64
3916                         for shift := uint(0); ; shift += 7 {
3917                                 if shift >= 64 {
3918                                         return ErrIntOverflowGenerated
3919                                 }
3920                                 if iNdEx >= l {
3921                                         return io.ErrUnexpectedEOF
3922                                 }
3923                                 b := dAtA[iNdEx]
3924                                 iNdEx++
3925                                 stringLen |= (uint64(b) & 0x7F) << shift
3926                                 if b < 0x80 {
3927                                         break
3928                                 }
3929                         }
3930                         intStringLen := int(stringLen)
3931                         if intStringLen < 0 {
3932                                 return ErrInvalidLengthGenerated
3933                         }
3934                         postIndex := iNdEx + intStringLen
3935                         if postIndex > l {
3936                                 return io.ErrUnexpectedEOF
3937                         }
3938                         m.TargetSelector = string(dAtA[iNdEx:postIndex])
3939                         iNdEx = postIndex
3940                 default:
3941                         iNdEx = preIndex
3942                         skippy, err := skipGenerated(dAtA[iNdEx:])
3943                         if err != nil {
3944                                 return err
3945                         }
3946                         if skippy < 0 {
3947                                 return ErrInvalidLengthGenerated
3948                         }
3949                         if (iNdEx + skippy) > l {
3950                                 return io.ErrUnexpectedEOF
3951                         }
3952                         iNdEx += skippy
3953                 }
3954         }
3955
3956         if iNdEx > l {
3957                 return io.ErrUnexpectedEOF
3958         }
3959         return nil
3960 }
3961 func (m *StatefulSet) Unmarshal(dAtA []byte) error {
3962         l := len(dAtA)
3963         iNdEx := 0
3964         for iNdEx < l {
3965                 preIndex := iNdEx
3966                 var wire uint64
3967                 for shift := uint(0); ; shift += 7 {
3968                         if shift >= 64 {
3969                                 return ErrIntOverflowGenerated
3970                         }
3971                         if iNdEx >= l {
3972                                 return io.ErrUnexpectedEOF
3973                         }
3974                         b := dAtA[iNdEx]
3975                         iNdEx++
3976                         wire |= (uint64(b) & 0x7F) << shift
3977                         if b < 0x80 {
3978                                 break
3979                         }
3980                 }
3981                 fieldNum := int32(wire >> 3)
3982                 wireType := int(wire & 0x7)
3983                 if wireType == 4 {
3984                         return fmt.Errorf("proto: StatefulSet: wiretype end group for non-group")
3985                 }
3986                 if fieldNum <= 0 {
3987                         return fmt.Errorf("proto: StatefulSet: illegal tag %d (wire type %d)", fieldNum, wire)
3988                 }
3989                 switch fieldNum {
3990                 case 1:
3991                         if wireType != 2 {
3992                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3993                         }
3994                         var msglen int
3995                         for shift := uint(0); ; shift += 7 {
3996                                 if shift >= 64 {
3997                                         return ErrIntOverflowGenerated
3998                                 }
3999                                 if iNdEx >= l {
4000                                         return io.ErrUnexpectedEOF
4001                                 }
4002                                 b := dAtA[iNdEx]
4003                                 iNdEx++
4004                                 msglen |= (int(b) & 0x7F) << shift
4005                                 if b < 0x80 {
4006                                         break
4007                                 }
4008                         }
4009                         if msglen < 0 {
4010                                 return ErrInvalidLengthGenerated
4011                         }
4012                         postIndex := iNdEx + msglen
4013                         if postIndex > l {
4014                                 return io.ErrUnexpectedEOF
4015                         }
4016                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4017                                 return err
4018                         }
4019                         iNdEx = postIndex
4020                 case 2:
4021                         if wireType != 2 {
4022                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4023                         }
4024                         var msglen int
4025                         for shift := uint(0); ; shift += 7 {
4026                                 if shift >= 64 {
4027                                         return ErrIntOverflowGenerated
4028                                 }
4029                                 if iNdEx >= l {
4030                                         return io.ErrUnexpectedEOF
4031                                 }
4032                                 b := dAtA[iNdEx]
4033                                 iNdEx++
4034                                 msglen |= (int(b) & 0x7F) << shift
4035                                 if b < 0x80 {
4036                                         break
4037                                 }
4038                         }
4039                         if msglen < 0 {
4040                                 return ErrInvalidLengthGenerated
4041                         }
4042                         postIndex := iNdEx + msglen
4043                         if postIndex > l {
4044                                 return io.ErrUnexpectedEOF
4045                         }
4046                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4047                                 return err
4048                         }
4049                         iNdEx = postIndex
4050                 case 3:
4051                         if wireType != 2 {
4052                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4053                         }
4054                         var msglen int
4055                         for shift := uint(0); ; shift += 7 {
4056                                 if shift >= 64 {
4057                                         return ErrIntOverflowGenerated
4058                                 }
4059                                 if iNdEx >= l {
4060                                         return io.ErrUnexpectedEOF
4061                                 }
4062                                 b := dAtA[iNdEx]
4063                                 iNdEx++
4064                                 msglen |= (int(b) & 0x7F) << shift
4065                                 if b < 0x80 {
4066                                         break
4067                                 }
4068                         }
4069                         if msglen < 0 {
4070                                 return ErrInvalidLengthGenerated
4071                         }
4072                         postIndex := iNdEx + msglen
4073                         if postIndex > l {
4074                                 return io.ErrUnexpectedEOF
4075                         }
4076                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4077                                 return err
4078                         }
4079                         iNdEx = postIndex
4080                 default:
4081                         iNdEx = preIndex
4082                         skippy, err := skipGenerated(dAtA[iNdEx:])
4083                         if err != nil {
4084                                 return err
4085                         }
4086                         if skippy < 0 {
4087                                 return ErrInvalidLengthGenerated
4088                         }
4089                         if (iNdEx + skippy) > l {
4090                                 return io.ErrUnexpectedEOF
4091                         }
4092                         iNdEx += skippy
4093                 }
4094         }
4095
4096         if iNdEx > l {
4097                 return io.ErrUnexpectedEOF
4098         }
4099         return nil
4100 }
4101 func (m *StatefulSetCondition) Unmarshal(dAtA []byte) error {
4102         l := len(dAtA)
4103         iNdEx := 0
4104         for iNdEx < l {
4105                 preIndex := iNdEx
4106                 var wire uint64
4107                 for shift := uint(0); ; shift += 7 {
4108                         if shift >= 64 {
4109                                 return ErrIntOverflowGenerated
4110                         }
4111                         if iNdEx >= l {
4112                                 return io.ErrUnexpectedEOF
4113                         }
4114                         b := dAtA[iNdEx]
4115                         iNdEx++
4116                         wire |= (uint64(b) & 0x7F) << shift
4117                         if b < 0x80 {
4118                                 break
4119                         }
4120                 }
4121                 fieldNum := int32(wire >> 3)
4122                 wireType := int(wire & 0x7)
4123                 if wireType == 4 {
4124                         return fmt.Errorf("proto: StatefulSetCondition: wiretype end group for non-group")
4125                 }
4126                 if fieldNum <= 0 {
4127                         return fmt.Errorf("proto: StatefulSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4128                 }
4129                 switch fieldNum {
4130                 case 1:
4131                         if wireType != 2 {
4132                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4133                         }
4134                         var stringLen uint64
4135                         for shift := uint(0); ; shift += 7 {
4136                                 if shift >= 64 {
4137                                         return ErrIntOverflowGenerated
4138                                 }
4139                                 if iNdEx >= l {
4140                                         return io.ErrUnexpectedEOF
4141                                 }
4142                                 b := dAtA[iNdEx]
4143                                 iNdEx++
4144                                 stringLen |= (uint64(b) & 0x7F) << shift
4145                                 if b < 0x80 {
4146                                         break
4147                                 }
4148                         }
4149                         intStringLen := int(stringLen)
4150                         if intStringLen < 0 {
4151                                 return ErrInvalidLengthGenerated
4152                         }
4153                         postIndex := iNdEx + intStringLen
4154                         if postIndex > l {
4155                                 return io.ErrUnexpectedEOF
4156                         }
4157                         m.Type = StatefulSetConditionType(dAtA[iNdEx:postIndex])
4158                         iNdEx = postIndex
4159                 case 2:
4160                         if wireType != 2 {
4161                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4162                         }
4163                         var stringLen uint64
4164                         for shift := uint(0); ; shift += 7 {
4165                                 if shift >= 64 {
4166                                         return ErrIntOverflowGenerated
4167                                 }
4168                                 if iNdEx >= l {
4169                                         return io.ErrUnexpectedEOF
4170                                 }
4171                                 b := dAtA[iNdEx]
4172                                 iNdEx++
4173                                 stringLen |= (uint64(b) & 0x7F) << shift
4174                                 if b < 0x80 {
4175                                         break
4176                                 }
4177                         }
4178                         intStringLen := int(stringLen)
4179                         if intStringLen < 0 {
4180                                 return ErrInvalidLengthGenerated
4181                         }
4182                         postIndex := iNdEx + intStringLen
4183                         if postIndex > l {
4184                                 return io.ErrUnexpectedEOF
4185                         }
4186                         m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
4187                         iNdEx = postIndex
4188                 case 3:
4189                         if wireType != 2 {
4190                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4191                         }
4192                         var msglen int
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                                 msglen |= (int(b) & 0x7F) << shift
4203                                 if b < 0x80 {
4204                                         break
4205                                 }
4206                         }
4207                         if msglen < 0 {
4208                                 return ErrInvalidLengthGenerated
4209                         }
4210                         postIndex := iNdEx + msglen
4211                         if postIndex > l {
4212                                 return io.ErrUnexpectedEOF
4213                         }
4214                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4215                                 return err
4216                         }
4217                         iNdEx = postIndex
4218                 case 4:
4219                         if wireType != 2 {
4220                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4221                         }
4222                         var stringLen uint64
4223                         for shift := uint(0); ; shift += 7 {
4224                                 if shift >= 64 {
4225                                         return ErrIntOverflowGenerated
4226                                 }
4227                                 if iNdEx >= l {
4228                                         return io.ErrUnexpectedEOF
4229                                 }
4230                                 b := dAtA[iNdEx]
4231                                 iNdEx++
4232                                 stringLen |= (uint64(b) & 0x7F) << shift
4233                                 if b < 0x80 {
4234                                         break
4235                                 }
4236                         }
4237                         intStringLen := int(stringLen)
4238                         if intStringLen < 0 {
4239                                 return ErrInvalidLengthGenerated
4240                         }
4241                         postIndex := iNdEx + intStringLen
4242                         if postIndex > l {
4243                                 return io.ErrUnexpectedEOF
4244                         }
4245                         m.Reason = string(dAtA[iNdEx:postIndex])
4246                         iNdEx = postIndex
4247                 case 5:
4248                         if wireType != 2 {
4249                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
4250                         }
4251                         var stringLen uint64
4252                         for shift := uint(0); ; shift += 7 {
4253                                 if shift >= 64 {
4254                                         return ErrIntOverflowGenerated
4255                                 }
4256                                 if iNdEx >= l {
4257                                         return io.ErrUnexpectedEOF
4258                                 }
4259                                 b := dAtA[iNdEx]
4260                                 iNdEx++
4261                                 stringLen |= (uint64(b) & 0x7F) << shift
4262                                 if b < 0x80 {
4263                                         break
4264                                 }
4265                         }
4266                         intStringLen := int(stringLen)
4267                         if intStringLen < 0 {
4268                                 return ErrInvalidLengthGenerated
4269                         }
4270                         postIndex := iNdEx + intStringLen
4271                         if postIndex > l {
4272                                 return io.ErrUnexpectedEOF
4273                         }
4274                         m.Message = string(dAtA[iNdEx:postIndex])
4275                         iNdEx = postIndex
4276                 default:
4277                         iNdEx = preIndex
4278                         skippy, err := skipGenerated(dAtA[iNdEx:])
4279                         if err != nil {
4280                                 return err
4281                         }
4282                         if skippy < 0 {
4283                                 return ErrInvalidLengthGenerated
4284                         }
4285                         if (iNdEx + skippy) > l {
4286                                 return io.ErrUnexpectedEOF
4287                         }
4288                         iNdEx += skippy
4289                 }
4290         }
4291
4292         if iNdEx > l {
4293                 return io.ErrUnexpectedEOF
4294         }
4295         return nil
4296 }
4297 func (m *StatefulSetList) Unmarshal(dAtA []byte) error {
4298         l := len(dAtA)
4299         iNdEx := 0
4300         for iNdEx < l {
4301                 preIndex := iNdEx
4302                 var wire uint64
4303                 for shift := uint(0); ; shift += 7 {
4304                         if shift >= 64 {
4305                                 return ErrIntOverflowGenerated
4306                         }
4307                         if iNdEx >= l {
4308                                 return io.ErrUnexpectedEOF
4309                         }
4310                         b := dAtA[iNdEx]
4311                         iNdEx++
4312                         wire |= (uint64(b) & 0x7F) << shift
4313                         if b < 0x80 {
4314                                 break
4315                         }
4316                 }
4317                 fieldNum := int32(wire >> 3)
4318                 wireType := int(wire & 0x7)
4319                 if wireType == 4 {
4320                         return fmt.Errorf("proto: StatefulSetList: wiretype end group for non-group")
4321                 }
4322                 if fieldNum <= 0 {
4323                         return fmt.Errorf("proto: StatefulSetList: illegal tag %d (wire type %d)", fieldNum, wire)
4324                 }
4325                 switch fieldNum {
4326                 case 1:
4327                         if wireType != 2 {
4328                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4329                         }
4330                         var msglen int
4331                         for shift := uint(0); ; shift += 7 {
4332                                 if shift >= 64 {
4333                                         return ErrIntOverflowGenerated
4334                                 }
4335                                 if iNdEx >= l {
4336                                         return io.ErrUnexpectedEOF
4337                                 }
4338                                 b := dAtA[iNdEx]
4339                                 iNdEx++
4340                                 msglen |= (int(b) & 0x7F) << shift
4341                                 if b < 0x80 {
4342                                         break
4343                                 }
4344                         }
4345                         if msglen < 0 {
4346                                 return ErrInvalidLengthGenerated
4347                         }
4348                         postIndex := iNdEx + msglen
4349                         if postIndex > l {
4350                                 return io.ErrUnexpectedEOF
4351                         }
4352                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4353                                 return err
4354                         }
4355                         iNdEx = postIndex
4356                 case 2:
4357                         if wireType != 2 {
4358                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4359                         }
4360                         var msglen int
4361                         for shift := uint(0); ; shift += 7 {
4362                                 if shift >= 64 {
4363                                         return ErrIntOverflowGenerated
4364                                 }
4365                                 if iNdEx >= l {
4366                                         return io.ErrUnexpectedEOF
4367                                 }
4368                                 b := dAtA[iNdEx]
4369                                 iNdEx++
4370                                 msglen |= (int(b) & 0x7F) << shift
4371                                 if b < 0x80 {
4372                                         break
4373                                 }
4374                         }
4375                         if msglen < 0 {
4376                                 return ErrInvalidLengthGenerated
4377                         }
4378                         postIndex := iNdEx + msglen
4379                         if postIndex > l {
4380                                 return io.ErrUnexpectedEOF
4381                         }
4382                         m.Items = append(m.Items, StatefulSet{})
4383                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4384                                 return err
4385                         }
4386                         iNdEx = postIndex
4387                 default:
4388                         iNdEx = preIndex
4389                         skippy, err := skipGenerated(dAtA[iNdEx:])
4390                         if err != nil {
4391                                 return err
4392                         }
4393                         if skippy < 0 {
4394                                 return ErrInvalidLengthGenerated
4395                         }
4396                         if (iNdEx + skippy) > l {
4397                                 return io.ErrUnexpectedEOF
4398                         }
4399                         iNdEx += skippy
4400                 }
4401         }
4402
4403         if iNdEx > l {
4404                 return io.ErrUnexpectedEOF
4405         }
4406         return nil
4407 }
4408 func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error {
4409         l := len(dAtA)
4410         iNdEx := 0
4411         for iNdEx < l {
4412                 preIndex := iNdEx
4413                 var wire uint64
4414                 for shift := uint(0); ; shift += 7 {
4415                         if shift >= 64 {
4416                                 return ErrIntOverflowGenerated
4417                         }
4418                         if iNdEx >= l {
4419                                 return io.ErrUnexpectedEOF
4420                         }
4421                         b := dAtA[iNdEx]
4422                         iNdEx++
4423                         wire |= (uint64(b) & 0x7F) << shift
4424                         if b < 0x80 {
4425                                 break
4426                         }
4427                 }
4428                 fieldNum := int32(wire >> 3)
4429                 wireType := int(wire & 0x7)
4430                 if wireType == 4 {
4431                         return fmt.Errorf("proto: StatefulSetSpec: wiretype end group for non-group")
4432                 }
4433                 if fieldNum <= 0 {
4434                         return fmt.Errorf("proto: StatefulSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4435                 }
4436                 switch fieldNum {
4437                 case 1:
4438                         if wireType != 0 {
4439                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4440                         }
4441                         var v int32
4442                         for shift := uint(0); ; shift += 7 {
4443                                 if shift >= 64 {
4444                                         return ErrIntOverflowGenerated
4445                                 }
4446                                 if iNdEx >= l {
4447                                         return io.ErrUnexpectedEOF
4448                                 }
4449                                 b := dAtA[iNdEx]
4450                                 iNdEx++
4451                                 v |= (int32(b) & 0x7F) << shift
4452                                 if b < 0x80 {
4453                                         break
4454                                 }
4455                         }
4456                         m.Replicas = &v
4457                 case 2:
4458                         if wireType != 2 {
4459                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
4460                         }
4461                         var msglen int
4462                         for shift := uint(0); ; shift += 7 {
4463                                 if shift >= 64 {
4464                                         return ErrIntOverflowGenerated
4465                                 }
4466                                 if iNdEx >= l {
4467                                         return io.ErrUnexpectedEOF
4468                                 }
4469                                 b := dAtA[iNdEx]
4470                                 iNdEx++
4471                                 msglen |= (int(b) & 0x7F) << shift
4472                                 if b < 0x80 {
4473                                         break
4474                                 }
4475                         }
4476                         if msglen < 0 {
4477                                 return ErrInvalidLengthGenerated
4478                         }
4479                         postIndex := iNdEx + msglen
4480                         if postIndex > l {
4481                                 return io.ErrUnexpectedEOF
4482                         }
4483                         if m.Selector == nil {
4484                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
4485                         }
4486                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4487                                 return err
4488                         }
4489                         iNdEx = postIndex
4490                 case 3:
4491                         if wireType != 2 {
4492                                 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
4493                         }
4494                         var msglen int
4495                         for shift := uint(0); ; shift += 7 {
4496                                 if shift >= 64 {
4497                                         return ErrIntOverflowGenerated
4498                                 }
4499                                 if iNdEx >= l {
4500                                         return io.ErrUnexpectedEOF
4501                                 }
4502                                 b := dAtA[iNdEx]
4503                                 iNdEx++
4504                                 msglen |= (int(b) & 0x7F) << shift
4505                                 if b < 0x80 {
4506                                         break
4507                                 }
4508                         }
4509                         if msglen < 0 {
4510                                 return ErrInvalidLengthGenerated
4511                         }
4512                         postIndex := iNdEx + msglen
4513                         if postIndex > l {
4514                                 return io.ErrUnexpectedEOF
4515                         }
4516                         if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4517                                 return err
4518                         }
4519                         iNdEx = postIndex
4520                 case 4:
4521                         if wireType != 2 {
4522                                 return fmt.Errorf("proto: wrong wireType = %d for field VolumeClaimTemplates", wireType)
4523                         }
4524                         var msglen int
4525                         for shift := uint(0); ; shift += 7 {
4526                                 if shift >= 64 {
4527                                         return ErrIntOverflowGenerated
4528                                 }
4529                                 if iNdEx >= l {
4530                                         return io.ErrUnexpectedEOF
4531                                 }
4532                                 b := dAtA[iNdEx]
4533                                 iNdEx++
4534                                 msglen |= (int(b) & 0x7F) << shift
4535                                 if b < 0x80 {
4536                                         break
4537                                 }
4538                         }
4539                         if msglen < 0 {
4540                                 return ErrInvalidLengthGenerated
4541                         }
4542                         postIndex := iNdEx + msglen
4543                         if postIndex > l {
4544                                 return io.ErrUnexpectedEOF
4545                         }
4546                         m.VolumeClaimTemplates = append(m.VolumeClaimTemplates, k8s_io_api_core_v1.PersistentVolumeClaim{})
4547                         if err := m.VolumeClaimTemplates[len(m.VolumeClaimTemplates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4548                                 return err
4549                         }
4550                         iNdEx = postIndex
4551                 case 5:
4552                         if wireType != 2 {
4553                                 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
4554                         }
4555                         var stringLen uint64
4556                         for shift := uint(0); ; shift += 7 {
4557                                 if shift >= 64 {
4558                                         return ErrIntOverflowGenerated
4559                                 }
4560                                 if iNdEx >= l {
4561                                         return io.ErrUnexpectedEOF
4562                                 }
4563                                 b := dAtA[iNdEx]
4564                                 iNdEx++
4565                                 stringLen |= (uint64(b) & 0x7F) << shift
4566                                 if b < 0x80 {
4567                                         break
4568                                 }
4569                         }
4570                         intStringLen := int(stringLen)
4571                         if intStringLen < 0 {
4572                                 return ErrInvalidLengthGenerated
4573                         }
4574                         postIndex := iNdEx + intStringLen
4575                         if postIndex > l {
4576                                 return io.ErrUnexpectedEOF
4577                         }
4578                         m.ServiceName = string(dAtA[iNdEx:postIndex])
4579                         iNdEx = postIndex
4580                 case 6:
4581                         if wireType != 2 {
4582                                 return fmt.Errorf("proto: wrong wireType = %d for field PodManagementPolicy", wireType)
4583                         }
4584                         var stringLen uint64
4585                         for shift := uint(0); ; shift += 7 {
4586                                 if shift >= 64 {
4587                                         return ErrIntOverflowGenerated
4588                                 }
4589                                 if iNdEx >= l {
4590                                         return io.ErrUnexpectedEOF
4591                                 }
4592                                 b := dAtA[iNdEx]
4593                                 iNdEx++
4594                                 stringLen |= (uint64(b) & 0x7F) << shift
4595                                 if b < 0x80 {
4596                                         break
4597                                 }
4598                         }
4599                         intStringLen := int(stringLen)
4600                         if intStringLen < 0 {
4601                                 return ErrInvalidLengthGenerated
4602                         }
4603                         postIndex := iNdEx + intStringLen
4604                         if postIndex > l {
4605                                 return io.ErrUnexpectedEOF
4606                         }
4607                         m.PodManagementPolicy = PodManagementPolicyType(dAtA[iNdEx:postIndex])
4608                         iNdEx = postIndex
4609                 case 7:
4610                         if wireType != 2 {
4611                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
4612                         }
4613                         var msglen int
4614                         for shift := uint(0); ; shift += 7 {
4615                                 if shift >= 64 {
4616                                         return ErrIntOverflowGenerated
4617                                 }
4618                                 if iNdEx >= l {
4619                                         return io.ErrUnexpectedEOF
4620                                 }
4621                                 b := dAtA[iNdEx]
4622                                 iNdEx++
4623                                 msglen |= (int(b) & 0x7F) << shift
4624                                 if b < 0x80 {
4625                                         break
4626                                 }
4627                         }
4628                         if msglen < 0 {
4629                                 return ErrInvalidLengthGenerated
4630                         }
4631                         postIndex := iNdEx + msglen
4632                         if postIndex > l {
4633                                 return io.ErrUnexpectedEOF
4634                         }
4635                         if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4636                                 return err
4637                         }
4638                         iNdEx = postIndex
4639                 case 8:
4640                         if wireType != 0 {
4641                                 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
4642                         }
4643                         var v int32
4644                         for shift := uint(0); ; shift += 7 {
4645                                 if shift >= 64 {
4646                                         return ErrIntOverflowGenerated
4647                                 }
4648                                 if iNdEx >= l {
4649                                         return io.ErrUnexpectedEOF
4650                                 }
4651                                 b := dAtA[iNdEx]
4652                                 iNdEx++
4653                                 v |= (int32(b) & 0x7F) << shift
4654                                 if b < 0x80 {
4655                                         break
4656                                 }
4657                         }
4658                         m.RevisionHistoryLimit = &v
4659                 default:
4660                         iNdEx = preIndex
4661                         skippy, err := skipGenerated(dAtA[iNdEx:])
4662                         if err != nil {
4663                                 return err
4664                         }
4665                         if skippy < 0 {
4666                                 return ErrInvalidLengthGenerated
4667                         }
4668                         if (iNdEx + skippy) > l {
4669                                 return io.ErrUnexpectedEOF
4670                         }
4671                         iNdEx += skippy
4672                 }
4673         }
4674
4675         if iNdEx > l {
4676                 return io.ErrUnexpectedEOF
4677         }
4678         return nil
4679 }
4680 func (m *StatefulSetStatus) Unmarshal(dAtA []byte) error {
4681         l := len(dAtA)
4682         iNdEx := 0
4683         for iNdEx < l {
4684                 preIndex := iNdEx
4685                 var wire uint64
4686                 for shift := uint(0); ; shift += 7 {
4687                         if shift >= 64 {
4688                                 return ErrIntOverflowGenerated
4689                         }
4690                         if iNdEx >= l {
4691                                 return io.ErrUnexpectedEOF
4692                         }
4693                         b := dAtA[iNdEx]
4694                         iNdEx++
4695                         wire |= (uint64(b) & 0x7F) << shift
4696                         if b < 0x80 {
4697                                 break
4698                         }
4699                 }
4700                 fieldNum := int32(wire >> 3)
4701                 wireType := int(wire & 0x7)
4702                 if wireType == 4 {
4703                         return fmt.Errorf("proto: StatefulSetStatus: wiretype end group for non-group")
4704                 }
4705                 if fieldNum <= 0 {
4706                         return fmt.Errorf("proto: StatefulSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4707                 }
4708                 switch fieldNum {
4709                 case 1:
4710                         if wireType != 0 {
4711                                 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
4712                         }
4713                         var v int64
4714                         for shift := uint(0); ; shift += 7 {
4715                                 if shift >= 64 {
4716                                         return ErrIntOverflowGenerated
4717                                 }
4718                                 if iNdEx >= l {
4719                                         return io.ErrUnexpectedEOF
4720                                 }
4721                                 b := dAtA[iNdEx]
4722                                 iNdEx++
4723                                 v |= (int64(b) & 0x7F) << shift
4724                                 if b < 0x80 {
4725                                         break
4726                                 }
4727                         }
4728                         m.ObservedGeneration = &v
4729                 case 2:
4730                         if wireType != 0 {
4731                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4732                         }
4733                         m.Replicas = 0
4734                         for shift := uint(0); ; shift += 7 {
4735                                 if shift >= 64 {
4736                                         return ErrIntOverflowGenerated
4737                                 }
4738                                 if iNdEx >= l {
4739                                         return io.ErrUnexpectedEOF
4740                                 }
4741                                 b := dAtA[iNdEx]
4742                                 iNdEx++
4743                                 m.Replicas |= (int32(b) & 0x7F) << shift
4744                                 if b < 0x80 {
4745                                         break
4746                                 }
4747                         }
4748                 case 3:
4749                         if wireType != 0 {
4750                                 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
4751                         }
4752                         m.ReadyReplicas = 0
4753                         for shift := uint(0); ; shift += 7 {
4754                                 if shift >= 64 {
4755                                         return ErrIntOverflowGenerated
4756                                 }
4757                                 if iNdEx >= l {
4758                                         return io.ErrUnexpectedEOF
4759                                 }
4760                                 b := dAtA[iNdEx]
4761                                 iNdEx++
4762                                 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
4763                                 if b < 0x80 {
4764                                         break
4765                                 }
4766                         }
4767                 case 4:
4768                         if wireType != 0 {
4769                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
4770                         }
4771                         m.CurrentReplicas = 0
4772                         for shift := uint(0); ; shift += 7 {
4773                                 if shift >= 64 {
4774                                         return ErrIntOverflowGenerated
4775                                 }
4776                                 if iNdEx >= l {
4777                                         return io.ErrUnexpectedEOF
4778                                 }
4779                                 b := dAtA[iNdEx]
4780                                 iNdEx++
4781                                 m.CurrentReplicas |= (int32(b) & 0x7F) << shift
4782                                 if b < 0x80 {
4783                                         break
4784                                 }
4785                         }
4786                 case 5:
4787                         if wireType != 0 {
4788                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
4789                         }
4790                         m.UpdatedReplicas = 0
4791                         for shift := uint(0); ; shift += 7 {
4792                                 if shift >= 64 {
4793                                         return ErrIntOverflowGenerated
4794                                 }
4795                                 if iNdEx >= l {
4796                                         return io.ErrUnexpectedEOF
4797                                 }
4798                                 b := dAtA[iNdEx]
4799                                 iNdEx++
4800                                 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
4801                                 if b < 0x80 {
4802                                         break
4803                                 }
4804                         }
4805                 case 6:
4806                         if wireType != 2 {
4807                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentRevision", wireType)
4808                         }
4809                         var stringLen uint64
4810                         for shift := uint(0); ; shift += 7 {
4811                                 if shift >= 64 {
4812                                         return ErrIntOverflowGenerated
4813                                 }
4814                                 if iNdEx >= l {
4815                                         return io.ErrUnexpectedEOF
4816                                 }
4817                                 b := dAtA[iNdEx]
4818                                 iNdEx++
4819                                 stringLen |= (uint64(b) & 0x7F) << shift
4820                                 if b < 0x80 {
4821                                         break
4822                                 }
4823                         }
4824                         intStringLen := int(stringLen)
4825                         if intStringLen < 0 {
4826                                 return ErrInvalidLengthGenerated
4827                         }
4828                         postIndex := iNdEx + intStringLen
4829                         if postIndex > l {
4830                                 return io.ErrUnexpectedEOF
4831                         }
4832                         m.CurrentRevision = string(dAtA[iNdEx:postIndex])
4833                         iNdEx = postIndex
4834                 case 7:
4835                         if wireType != 2 {
4836                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdateRevision", wireType)
4837                         }
4838                         var stringLen uint64
4839                         for shift := uint(0); ; shift += 7 {
4840                                 if shift >= 64 {
4841                                         return ErrIntOverflowGenerated
4842                                 }
4843                                 if iNdEx >= l {
4844                                         return io.ErrUnexpectedEOF
4845                                 }
4846                                 b := dAtA[iNdEx]
4847                                 iNdEx++
4848                                 stringLen |= (uint64(b) & 0x7F) << shift
4849                                 if b < 0x80 {
4850                                         break
4851                                 }
4852                         }
4853                         intStringLen := int(stringLen)
4854                         if intStringLen < 0 {
4855                                 return ErrInvalidLengthGenerated
4856                         }
4857                         postIndex := iNdEx + intStringLen
4858                         if postIndex > l {
4859                                 return io.ErrUnexpectedEOF
4860                         }
4861                         m.UpdateRevision = string(dAtA[iNdEx:postIndex])
4862                         iNdEx = postIndex
4863                 case 9:
4864                         if wireType != 0 {
4865                                 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
4866                         }
4867                         var v int32
4868                         for shift := uint(0); ; shift += 7 {
4869                                 if shift >= 64 {
4870                                         return ErrIntOverflowGenerated
4871                                 }
4872                                 if iNdEx >= l {
4873                                         return io.ErrUnexpectedEOF
4874                                 }
4875                                 b := dAtA[iNdEx]
4876                                 iNdEx++
4877                                 v |= (int32(b) & 0x7F) << shift
4878                                 if b < 0x80 {
4879                                         break
4880                                 }
4881                         }
4882                         m.CollisionCount = &v
4883                 case 10:
4884                         if wireType != 2 {
4885                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
4886                         }
4887                         var msglen int
4888                         for shift := uint(0); ; shift += 7 {
4889                                 if shift >= 64 {
4890                                         return ErrIntOverflowGenerated
4891                                 }
4892                                 if iNdEx >= l {
4893                                         return io.ErrUnexpectedEOF
4894                                 }
4895                                 b := dAtA[iNdEx]
4896                                 iNdEx++
4897                                 msglen |= (int(b) & 0x7F) << shift
4898                                 if b < 0x80 {
4899                                         break
4900                                 }
4901                         }
4902                         if msglen < 0 {
4903                                 return ErrInvalidLengthGenerated
4904                         }
4905                         postIndex := iNdEx + msglen
4906                         if postIndex > l {
4907                                 return io.ErrUnexpectedEOF
4908                         }
4909                         m.Conditions = append(m.Conditions, StatefulSetCondition{})
4910                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4911                                 return err
4912                         }
4913                         iNdEx = postIndex
4914                 default:
4915                         iNdEx = preIndex
4916                         skippy, err := skipGenerated(dAtA[iNdEx:])
4917                         if err != nil {
4918                                 return err
4919                         }
4920                         if skippy < 0 {
4921                                 return ErrInvalidLengthGenerated
4922                         }
4923                         if (iNdEx + skippy) > l {
4924                                 return io.ErrUnexpectedEOF
4925                         }
4926                         iNdEx += skippy
4927                 }
4928         }
4929
4930         if iNdEx > l {
4931                 return io.ErrUnexpectedEOF
4932         }
4933         return nil
4934 }
4935 func (m *StatefulSetUpdateStrategy) Unmarshal(dAtA []byte) error {
4936         l := len(dAtA)
4937         iNdEx := 0
4938         for iNdEx < l {
4939                 preIndex := iNdEx
4940                 var wire uint64
4941                 for shift := uint(0); ; shift += 7 {
4942                         if shift >= 64 {
4943                                 return ErrIntOverflowGenerated
4944                         }
4945                         if iNdEx >= l {
4946                                 return io.ErrUnexpectedEOF
4947                         }
4948                         b := dAtA[iNdEx]
4949                         iNdEx++
4950                         wire |= (uint64(b) & 0x7F) << shift
4951                         if b < 0x80 {
4952                                 break
4953                         }
4954                 }
4955                 fieldNum := int32(wire >> 3)
4956                 wireType := int(wire & 0x7)
4957                 if wireType == 4 {
4958                         return fmt.Errorf("proto: StatefulSetUpdateStrategy: wiretype end group for non-group")
4959                 }
4960                 if fieldNum <= 0 {
4961                         return fmt.Errorf("proto: StatefulSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
4962                 }
4963                 switch fieldNum {
4964                 case 1:
4965                         if wireType != 2 {
4966                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4967                         }
4968                         var stringLen uint64
4969                         for shift := uint(0); ; shift += 7 {
4970                                 if shift >= 64 {
4971                                         return ErrIntOverflowGenerated
4972                                 }
4973                                 if iNdEx >= l {
4974                                         return io.ErrUnexpectedEOF
4975                                 }
4976                                 b := dAtA[iNdEx]
4977                                 iNdEx++
4978                                 stringLen |= (uint64(b) & 0x7F) << shift
4979                                 if b < 0x80 {
4980                                         break
4981                                 }
4982                         }
4983                         intStringLen := int(stringLen)
4984                         if intStringLen < 0 {
4985                                 return ErrInvalidLengthGenerated
4986                         }
4987                         postIndex := iNdEx + intStringLen
4988                         if postIndex > l {
4989                                 return io.ErrUnexpectedEOF
4990                         }
4991                         m.Type = StatefulSetUpdateStrategyType(dAtA[iNdEx:postIndex])
4992                         iNdEx = postIndex
4993                 case 2:
4994                         if wireType != 2 {
4995                                 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
4996                         }
4997                         var msglen int
4998                         for shift := uint(0); ; shift += 7 {
4999                                 if shift >= 64 {
5000                                         return ErrIntOverflowGenerated
5001                                 }
5002                                 if iNdEx >= l {
5003                                         return io.ErrUnexpectedEOF
5004                                 }
5005                                 b := dAtA[iNdEx]
5006                                 iNdEx++
5007                                 msglen |= (int(b) & 0x7F) << shift
5008                                 if b < 0x80 {
5009                                         break
5010                                 }
5011                         }
5012                         if msglen < 0 {
5013                                 return ErrInvalidLengthGenerated
5014                         }
5015                         postIndex := iNdEx + msglen
5016                         if postIndex > l {
5017                                 return io.ErrUnexpectedEOF
5018                         }
5019                         if m.RollingUpdate == nil {
5020                                 m.RollingUpdate = &RollingUpdateStatefulSetStrategy{}
5021                         }
5022                         if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5023                                 return err
5024                         }
5025                         iNdEx = postIndex
5026                 default:
5027                         iNdEx = preIndex
5028                         skippy, err := skipGenerated(dAtA[iNdEx:])
5029                         if err != nil {
5030                                 return err
5031                         }
5032                         if skippy < 0 {
5033                                 return ErrInvalidLengthGenerated
5034                         }
5035                         if (iNdEx + skippy) > l {
5036                                 return io.ErrUnexpectedEOF
5037                         }
5038                         iNdEx += skippy
5039                 }
5040         }
5041
5042         if iNdEx > l {
5043                 return io.ErrUnexpectedEOF
5044         }
5045         return nil
5046 }
5047 func skipGenerated(dAtA []byte) (n int, err error) {
5048         l := len(dAtA)
5049         iNdEx := 0
5050         for iNdEx < l {
5051                 var wire uint64
5052                 for shift := uint(0); ; shift += 7 {
5053                         if shift >= 64 {
5054                                 return 0, ErrIntOverflowGenerated
5055                         }
5056                         if iNdEx >= l {
5057                                 return 0, io.ErrUnexpectedEOF
5058                         }
5059                         b := dAtA[iNdEx]
5060                         iNdEx++
5061                         wire |= (uint64(b) & 0x7F) << shift
5062                         if b < 0x80 {
5063                                 break
5064                         }
5065                 }
5066                 wireType := int(wire & 0x7)
5067                 switch wireType {
5068                 case 0:
5069                         for shift := uint(0); ; shift += 7 {
5070                                 if shift >= 64 {
5071                                         return 0, ErrIntOverflowGenerated
5072                                 }
5073                                 if iNdEx >= l {
5074                                         return 0, io.ErrUnexpectedEOF
5075                                 }
5076                                 iNdEx++
5077                                 if dAtA[iNdEx-1] < 0x80 {
5078                                         break
5079                                 }
5080                         }
5081                         return iNdEx, nil
5082                 case 1:
5083                         iNdEx += 8
5084                         return iNdEx, nil
5085                 case 2:
5086                         var length int
5087                         for shift := uint(0); ; shift += 7 {
5088                                 if shift >= 64 {
5089                                         return 0, ErrIntOverflowGenerated
5090                                 }
5091                                 if iNdEx >= l {
5092                                         return 0, io.ErrUnexpectedEOF
5093                                 }
5094                                 b := dAtA[iNdEx]
5095                                 iNdEx++
5096                                 length |= (int(b) & 0x7F) << shift
5097                                 if b < 0x80 {
5098                                         break
5099                                 }
5100                         }
5101                         iNdEx += length
5102                         if length < 0 {
5103                                 return 0, ErrInvalidLengthGenerated
5104                         }
5105                         return iNdEx, nil
5106                 case 3:
5107                         for {
5108                                 var innerWire uint64
5109                                 var start int = iNdEx
5110                                 for shift := uint(0); ; shift += 7 {
5111                                         if shift >= 64 {
5112                                                 return 0, ErrIntOverflowGenerated
5113                                         }
5114                                         if iNdEx >= l {
5115                                                 return 0, io.ErrUnexpectedEOF
5116                                         }
5117                                         b := dAtA[iNdEx]
5118                                         iNdEx++
5119                                         innerWire |= (uint64(b) & 0x7F) << shift
5120                                         if b < 0x80 {
5121                                                 break
5122                                         }
5123                                 }
5124                                 innerWireType := int(innerWire & 0x7)
5125                                 if innerWireType == 4 {
5126                                         break
5127                                 }
5128                                 next, err := skipGenerated(dAtA[start:])
5129                                 if err != nil {
5130                                         return 0, err
5131                                 }
5132                                 iNdEx = start + next
5133                         }
5134                         return iNdEx, nil
5135                 case 4:
5136                         return iNdEx, nil
5137                 case 5:
5138                         iNdEx += 4
5139                         return iNdEx, nil
5140                 default:
5141                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
5142                 }
5143         }
5144         panic("unreachable")
5145 }
5146
5147 var (
5148         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
5149         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
5150 )
5151
5152 func init() {
5153         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/apps/v1beta1/generated.proto", fileDescriptorGenerated)
5154 }
5155
5156 var fileDescriptorGenerated = []byte{
5157         // 1859 bytes of a gzipped FileDescriptorProto
5158         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcd, 0x6f, 0x24, 0x47,
5159         0x15, 0x77, 0x8f, 0x67, 0xec, 0xf1, 0x73, 0x3c, 0xde, 0x2d, 0x9b, 0xf5, 0xc4, 0x81, 0xb1, 0xd5,
5160         0x44, 0x89, 0xf3, 0xe1, 0x9e, 0xac, 0x13, 0xa2, 0x64, 0x17, 0x45, 0x78, 0xbc, 0x4b, 0xb2, 0x91,
5161         0x8d, 0x9d, 0xb2, 0x1d, 0x44, 0x00, 0x29, 0x35, 0x3d, 0xb5, 0xb3, 0x1d, 0xf7, 0x97, 0xba, 0x6b,
5162         0x86, 0x1d, 0x71, 0xe1, 0x0f, 0x40, 0x0a, 0x67, 0xfe, 0x0a, 0x8e, 0x08, 0x6e, 0x9c, 0xf6, 0x82,
5163         0x14, 0x71, 0x21, 0x27, 0x8b, 0x9d, 0x5c, 0x81, 0x1b, 0x97, 0x95, 0x90, 0x50, 0x55, 0x57, 0x7f,
5164         0x77, 0xdb, 0x6d, 0xa4, 0xf5, 0x21, 0xb7, 0xe9, 0x7a, 0xef, 0xfd, 0x5e, 0x7d, 0xbc, 0xaf, 0xdf,
5165         0xc0, 0x8f, 0xce, 0xde, 0xf3, 0x35, 0xc3, 0xe9, 0x9e, 0x8d, 0xfa, 0xd4, 0xb3, 0x29, 0xa3, 0x7e,
5166         0x77, 0x4c, 0xed, 0x81, 0xe3, 0x75, 0xa5, 0x80, 0xb8, 0x46, 0x97, 0xb8, 0xae, 0xdf, 0x1d, 0xdf,
5167         0xee, 0x53, 0x46, 0x6e, 0x77, 0x87, 0xd4, 0xa6, 0x1e, 0x61, 0x74, 0xa0, 0xb9, 0x9e, 0xc3, 0x1c,
5168         0xb4, 0x16, 0x28, 0x6a, 0xc4, 0x35, 0x34, 0xae, 0xa8, 0x49, 0xc5, 0xf5, 0xed, 0xa1, 0xc1, 0x1e,
5169         0x8d, 0xfa, 0x9a, 0xee, 0x58, 0xdd, 0xa1, 0x33, 0x74, 0xba, 0x42, 0xbf, 0x3f, 0x7a, 0x28, 0xbe,
5170         0xc4, 0x87, 0xf8, 0x15, 0xe0, 0xac, 0xab, 0x09, 0x87, 0xba, 0xe3, 0xd1, 0xee, 0x38, 0xe7, 0x6b,
5171         0xfd, 0x9d, 0x58, 0xc7, 0x22, 0xfa, 0x23, 0xc3, 0xa6, 0xde, 0xa4, 0xeb, 0x9e, 0x0d, 0xf9, 0x82,
5172         0xdf, 0xb5, 0x28, 0x23, 0x45, 0x56, 0xdd, 0x32, 0x2b, 0x6f, 0x64, 0x33, 0xc3, 0xa2, 0x39, 0x83,
5173         0x77, 0x2f, 0x33, 0xf0, 0xf5, 0x47, 0xd4, 0x22, 0x39, 0xbb, 0xb7, 0xcb, 0xec, 0x46, 0xcc, 0x30,
5174         0xbb, 0x86, 0xcd, 0x7c, 0xe6, 0x65, 0x8d, 0xd4, 0xff, 0x28, 0x80, 0xf6, 0x1c, 0x9b, 0x79, 0x8e,
5175         0x69, 0x52, 0x0f, 0xd3, 0xb1, 0xe1, 0x1b, 0x8e, 0x8d, 0x3e, 0x87, 0x26, 0x3f, 0xcf, 0x80, 0x30,
5176         0xd2, 0x56, 0x36, 0x95, 0xad, 0xc5, 0x9d, 0xb7, 0xb4, 0xf8, 0xa6, 0x23, 0x78, 0xcd, 0x3d, 0x1b,
5177         0xf2, 0x05, 0x5f, 0xe3, 0xda, 0xda, 0xf8, 0xb6, 0x76, 0xd8, 0xff, 0x82, 0xea, 0xec, 0x80, 0x32,
5178         0xd2, 0x43, 0x4f, 0xce, 0x37, 0x66, 0xa6, 0xe7, 0x1b, 0x10, 0xaf, 0xe1, 0x08, 0x15, 0x1d, 0x42,
5179         0x5d, 0xa0, 0xd7, 0x04, 0xfa, 0x76, 0x29, 0xba, 0x3c, 0xb4, 0x86, 0xc9, 0xaf, 0xee, 0x3f, 0x66,
5180         0xd4, 0xe6, 0xdb, 0xeb, 0xbd, 0x20, 0xa1, 0xeb, 0xf7, 0x08, 0x23, 0x58, 0x00, 0xa1, 0x37, 0xa1,
5181         0xe9, 0xc9, 0xed, 0xb7, 0x67, 0x37, 0x95, 0xad, 0xd9, 0xde, 0x0d, 0xa9, 0xd5, 0x0c, 0x8f, 0x85,
5182         0x23, 0x0d, 0xf5, 0x89, 0x02, 0xb7, 0xf2, 0xe7, 0xde, 0x37, 0x7c, 0x86, 0x7e, 0x91, 0x3b, 0xbb,
5183         0x56, 0xed, 0xec, 0xdc, 0x5a, 0x9c, 0x3c, 0x72, 0x1c, 0xae, 0x24, 0xce, 0x7d, 0x04, 0x0d, 0x83,
5184         0x51, 0xcb, 0x6f, 0xd7, 0x36, 0x67, 0xb7, 0x16, 0x77, 0xde, 0xd0, 0x4a, 0x02, 0x58, 0xcb, 0xef,
5185         0xae, 0xb7, 0x24, 0x71, 0x1b, 0x0f, 0x38, 0x02, 0x0e, 0x80, 0xd4, 0xdf, 0xd6, 0x00, 0xee, 0x51,
5186         0xd7, 0x74, 0x26, 0x16, 0xb5, 0xd9, 0x35, 0x3c, 0xdd, 0x03, 0xa8, 0xfb, 0x2e, 0xd5, 0xe5, 0xd3,
5187         0xbd, 0x5a, 0x7a, 0x82, 0x78, 0x53, 0xc7, 0x2e, 0xd5, 0xe3, 0x47, 0xe3, 0x5f, 0x58, 0x40, 0xa0,
5188         0x4f, 0x60, 0xce, 0x67, 0x84, 0x8d, 0x7c, 0xf1, 0x64, 0x8b, 0x3b, 0xaf, 0x55, 0x01, 0x13, 0x06,
5189         0xbd, 0x96, 0x84, 0x9b, 0x0b, 0xbe, 0xb1, 0x04, 0x52, 0xff, 0x3e, 0x0b, 0x2b, 0xb1, 0xf2, 0x9e,
5190         0x63, 0x0f, 0x0c, 0xc6, 0x43, 0xfa, 0x2e, 0xd4, 0xd9, 0xc4, 0xa5, 0xe2, 0x4e, 0x16, 0x7a, 0xaf,
5191         0x86, 0x9b, 0x39, 0x99, 0xb8, 0xf4, 0xd9, 0xf9, 0xc6, 0x5a, 0x81, 0x09, 0x17, 0x61, 0x61, 0x84,
5192         0xf6, 0xa3, 0x7d, 0xd6, 0x84, 0xf9, 0x3b, 0x69, 0xe7, 0xcf, 0xce, 0x37, 0x0a, 0x0a, 0x88, 0x16,
5193         0x21, 0xa5, 0xb7, 0x88, 0x5e, 0x81, 0x39, 0x8f, 0x12, 0xdf, 0xb1, 0xdb, 0x75, 0x81, 0x16, 0x1d,
5194         0x05, 0x8b, 0x55, 0x2c, 0xa5, 0xe8, 0x35, 0x98, 0xb7, 0xa8, 0xef, 0x93, 0x21, 0x6d, 0x37, 0x84,
5195         0xe2, 0xb2, 0x54, 0x9c, 0x3f, 0x08, 0x96, 0x71, 0x28, 0x47, 0x5f, 0x40, 0xcb, 0x24, 0x3e, 0x3b,
5196         0x75, 0x07, 0x84, 0xd1, 0x13, 0xc3, 0xa2, 0xed, 0x39, 0x71, 0xa1, 0xaf, 0x57, 0x7b, 0x7b, 0x6e,
5197         0xd1, 0xbb, 0x25, 0xd1, 0x5b, 0xfb, 0x29, 0x24, 0x9c, 0x41, 0x46, 0x63, 0x40, 0x7c, 0xe5, 0xc4,
5198         0x23, 0xb6, 0x1f, 0x5c, 0x14, 0xf7, 0x37, 0x7f, 0x65, 0x7f, 0xeb, 0xd2, 0x1f, 0xda, 0xcf, 0xa1,
5199         0xe1, 0x02, 0x0f, 0xea, 0x1f, 0x15, 0x68, 0xc5, 0xcf, 0x74, 0x0d, 0xb9, 0xfa, 0x51, 0x3a, 0x57,
5200         0xbf, 0x5f, 0x21, 0x38, 0x4b, 0x72, 0xf4, 0x9f, 0x35, 0x40, 0xb1, 0x12, 0x76, 0x4c, 0xb3, 0x4f,
5201         0xf4, 0x33, 0xb4, 0x09, 0x75, 0x9b, 0x58, 0x61, 0x4c, 0x46, 0x09, 0xf2, 0x13, 0x62, 0x51, 0x2c,
5202         0x24, 0xe8, 0x4b, 0x05, 0xd0, 0x48, 0x5c, 0xfd, 0x60, 0xd7, 0xb6, 0x1d, 0x46, 0xf8, 0x6d, 0x84,
5203         0x1b, 0xda, 0xab, 0xb0, 0xa1, 0xd0, 0x97, 0x76, 0x9a, 0x43, 0xb9, 0x6f, 0x33, 0x6f, 0x12, 0xbf,
5204         0x42, 0x5e, 0x01, 0x17, 0xb8, 0x46, 0x3f, 0x07, 0xf0, 0x24, 0xe6, 0x89, 0x23, 0xd3, 0xb6, 0xbc,
5205         0x06, 0x84, 0xee, 0xf7, 0x1c, 0xfb, 0xa1, 0x31, 0x8c, 0x0b, 0x0b, 0x8e, 0x20, 0x70, 0x02, 0x6e,
5206         0xfd, 0x3e, 0xac, 0x95, 0xec, 0x13, 0xdd, 0x80, 0xd9, 0x33, 0x3a, 0x09, 0xae, 0x0a, 0xf3, 0x9f,
5207         0x68, 0x15, 0x1a, 0x63, 0x62, 0x8e, 0x68, 0x90, 0x93, 0x38, 0xf8, 0xb8, 0x53, 0x7b, 0x4f, 0x51,
5208         0xff, 0xd0, 0x48, 0x46, 0x0a, 0xaf, 0x37, 0x68, 0x8b, 0xb7, 0x07, 0xd7, 0x34, 0x74, 0xe2, 0x0b,
5209         0x8c, 0x46, 0xef, 0x85, 0xa0, 0x35, 0x04, 0x6b, 0x38, 0x92, 0xa2, 0x5f, 0x42, 0xd3, 0xa7, 0x26,
5210         0xd5, 0x99, 0xe3, 0xc9, 0x12, 0xf7, 0x76, 0xc5, 0x98, 0x22, 0x7d, 0x6a, 0x1e, 0x4b, 0xd3, 0x00,
5211         0x3e, 0xfc, 0xc2, 0x11, 0x24, 0xfa, 0x04, 0x9a, 0x8c, 0x5a, 0xae, 0x49, 0x18, 0x95, 0xb7, 0x97,
5212         0x8a, 0x2b, 0x5e, 0x3b, 0x38, 0xd8, 0x91, 0x33, 0x38, 0x91, 0x6a, 0xa2, 0x7a, 0x46, 0x71, 0x1a,
5213         0xae, 0xe2, 0x08, 0x06, 0xfd, 0x0c, 0x9a, 0x3e, 0xe3, 0x5d, 0x7d, 0x38, 0x11, 0x15, 0xe5, 0xa2,
5214         0xb6, 0x92, 0xac, 0xa3, 0x81, 0x49, 0x0c, 0x1d, 0xae, 0xe0, 0x08, 0x0e, 0xed, 0xc2, 0xb2, 0x65,
5215         0xd8, 0x98, 0x92, 0xc1, 0xe4, 0x98, 0xea, 0x8e, 0x3d, 0xf0, 0x45, 0x29, 0x6a, 0xf4, 0xd6, 0xa4,
5216         0xd1, 0xf2, 0x41, 0x5a, 0x8c, 0xb3, 0xfa, 0x68, 0x1f, 0x56, 0xc3, 0xb6, 0xfb, 0x91, 0xe1, 0x33,
5217         0xc7, 0x9b, 0xec, 0x1b, 0x96, 0xc1, 0x44, 0x81, 0x6a, 0xf4, 0xda, 0xd3, 0xf3, 0x8d, 0x55, 0x5c,
5218         0x20, 0xc7, 0x85, 0x56, 0xbc, 0x76, 0xba, 0x64, 0xe4, 0xd3, 0x81, 0x28, 0x38, 0xcd, 0xb8, 0x76,
5219         0x1e, 0x89, 0x55, 0x2c, 0xa5, 0xe8, 0xa7, 0xa9, 0x30, 0x6d, 0x5e, 0x2d, 0x4c, 0x5b, 0xe5, 0x21,
5220         0x8a, 0x4e, 0x61, 0xcd, 0xf5, 0x9c, 0xa1, 0x47, 0x7d, 0xff, 0x1e, 0x25, 0x03, 0xd3, 0xb0, 0x69,
5221         0x78, 0x33, 0x0b, 0xe2, 0x44, 0x2f, 0x4d, 0xcf, 0x37, 0xd6, 0x8e, 0x8a, 0x55, 0x70, 0x99, 0xad,
5222         0xfa, 0x97, 0x3a, 0xdc, 0xc8, 0xf6, 0x38, 0xf4, 0x31, 0x20, 0xa7, 0xef, 0x53, 0x6f, 0x4c, 0x07,
5223         0x1f, 0x06, 0x83, 0x1b, 0x9f, 0x6e, 0x14, 0x31, 0xdd, 0x44, 0x79, 0x7b, 0x98, 0xd3, 0xc0, 0x05,
5224         0x56, 0xc1, 0x7c, 0x24, 0x13, 0xa0, 0x26, 0x36, 0x9a, 0x98, 0x8f, 0x72, 0x49, 0xb0, 0x0b, 0xcb,
5225         0x32, 0xf7, 0x43, 0xa1, 0x08, 0xd6, 0xc4, 0xbb, 0x9f, 0xa6, 0xc5, 0x38, 0xab, 0x8f, 0x3e, 0x84,
5226         0x9b, 0x64, 0x4c, 0x0c, 0x93, 0xf4, 0x4d, 0x1a, 0x81, 0xd4, 0x05, 0xc8, 0x8b, 0x12, 0xe4, 0xe6,
5227         0x6e, 0x56, 0x01, 0xe7, 0x6d, 0xd0, 0x01, 0xac, 0x8c, 0xec, 0x3c, 0x54, 0x10, 0x87, 0x2f, 0x49,
5228         0xa8, 0x95, 0xd3, 0xbc, 0x0a, 0x2e, 0xb2, 0x43, 0x9f, 0x03, 0xe8, 0x61, 0x63, 0xf6, 0xdb, 0x73,
5229         0xa2, 0x92, 0xbe, 0x59, 0x21, 0x5f, 0xa2, 0x6e, 0x1e, 0x57, 0xb1, 0x68, 0xc9, 0xc7, 0x09, 0x4c,
5230         0x74, 0x17, 0x96, 0x3c, 0x9e, 0x01, 0xd1, 0x56, 0xe7, 0xc5, 0x56, 0xbf, 0x23, 0xcd, 0x96, 0x70,
5231         0x52, 0x88, 0xd3, 0xba, 0xe8, 0x0e, 0xb4, 0x74, 0xc7, 0x34, 0x45, 0xe4, 0xef, 0x39, 0x23, 0x9b,
5232         0x89, 0xe0, 0x6d, 0xf4, 0x10, 0xef, 0xcc, 0x7b, 0x29, 0x09, 0xce, 0x68, 0xaa, 0x7f, 0x56, 0x92,
5233         0x6d, 0x26, 0x4c, 0x67, 0x74, 0x27, 0x35, 0xfa, 0xbc, 0x92, 0x19, 0x7d, 0x6e, 0xe5, 0x2d, 0x12,
5234         0x93, 0x8f, 0x01, 0x4b, 0x3c, 0xf8, 0x0d, 0x7b, 0x18, 0x3c, 0xb8, 0x2c, 0x89, 0x6f, 0x5d, 0x98,
5235         0x4a, 0x91, 0x76, 0xa2, 0x31, 0xde, 0x14, 0x27, 0x4f, 0x0a, 0x71, 0x1a, 0x59, 0xfd, 0x00, 0x5a,
5236         0xe9, 0x3c, 0x4c, 0xcd, 0xf4, 0xca, 0xa5, 0x33, 0xfd, 0x37, 0x0a, 0xac, 0x95, 0x78, 0x47, 0x26,
5237         0xb4, 0x2c, 0xf2, 0x38, 0x11, 0x23, 0x97, 0xce, 0xc6, 0x9c, 0x35, 0x69, 0x01, 0x6b, 0xd2, 0x1e,
5238         0xd8, 0xec, 0xd0, 0x3b, 0x66, 0x9e, 0x61, 0x0f, 0x83, 0x77, 0x38, 0x48, 0x61, 0xe1, 0x0c, 0x36,
5239         0xfa, 0x0c, 0x9a, 0x16, 0x79, 0x7c, 0x3c, 0xf2, 0x86, 0x45, 0xf7, 0x55, 0xcd, 0x8f, 0xe8, 0x1f,
5240         0x07, 0x12, 0x05, 0x47, 0x78, 0xea, 0x21, 0x6c, 0xa6, 0x0e, 0xc9, 0x4b, 0x05, 0x7d, 0x38, 0x32,
5241         0x8f, 0x69, 0xfc, 0xe0, 0x6f, 0xc0, 0x82, 0x4b, 0x3c, 0x66, 0x44, 0xe5, 0xa2, 0xd1, 0x5b, 0x9a,
5242         0x9e, 0x6f, 0x2c, 0x1c, 0x85, 0x8b, 0x38, 0x96, 0xab, 0xff, 0x55, 0xa0, 0x71, 0xac, 0x13, 0x93,
5243         0x5e, 0x03, 0x75, 0xb8, 0x97, 0xa2, 0x0e, 0x6a, 0x69, 0x10, 0x89, 0xfd, 0x94, 0xb2, 0x86, 0xfd,
5244         0x0c, 0x6b, 0x78, 0xf9, 0x12, 0x9c, 0x8b, 0x09, 0xc3, 0xfb, 0xb0, 0x10, 0xb9, 0x4b, 0x55, 0x49,
5245         0xe5, 0xb2, 0x2a, 0xa9, 0xfe, 0xbe, 0x06, 0x8b, 0x09, 0x17, 0x57, 0xb3, 0xe6, 0xd7, 0x9d, 0x18,
5246         0x34, 0x78, 0x19, 0xda, 0xa9, 0x72, 0x10, 0x2d, 0x1c, 0x2a, 0x82, 0xf9, 0x2d, 0xee, 0xde, 0xf9,
5247         0x59, 0xe3, 0x03, 0x68, 0x31, 0xe2, 0x0d, 0x29, 0x0b, 0x65, 0xe2, 0xc2, 0x16, 0xe2, 0x49, 0xff,
5248         0x24, 0x25, 0xc5, 0x19, 0xed, 0xf5, 0xbb, 0xb0, 0x94, 0x72, 0x76, 0xa5, 0x21, 0xec, 0x4b, 0x7e,
5249         0x39, 0x71, 0x70, 0x5e, 0x43, 0x74, 0x7d, 0x9c, 0x8a, 0xae, 0xad, 0xf2, 0xcb, 0x4c, 0xa4, 0x4c,
5250         0x59, 0x8c, 0xe1, 0x4c, 0x8c, 0xbd, 0x5e, 0x09, 0xed, 0xe2, 0x48, 0xfb, 0x57, 0x0d, 0x56, 0x13,
5251         0xda, 0x31, 0x37, 0xfd, 0x61, 0xaa, 0x40, 0x6f, 0x65, 0x0a, 0x74, 0xbb, 0xc8, 0xe6, 0xb9, 0x91,
5252         0xd3, 0x62, 0x76, 0x37, 0xfb, 0xbc, 0xd9, 0xdd, 0x73, 0x20, 0xc5, 0xea, 0x9f, 0x14, 0x58, 0x4e,
5253         0xdc, 0xdd, 0x35, 0x30, 0xc6, 0x07, 0x69, 0xc6, 0xf8, 0x72, 0x95, 0xa0, 0x29, 0xa1, 0x8c, 0x7f,
5254         0x6d, 0xa4, 0x36, 0xff, 0xad, 0x27, 0x31, 0xbf, 0x86, 0xd5, 0xb1, 0x63, 0x8e, 0x2c, 0xba, 0x67,
5255         0x12, 0xc3, 0x0a, 0x15, 0xf8, 0xc4, 0x38, 0x9b, 0xfd, 0x63, 0x28, 0x82, 0xa7, 0x9e, 0x6f, 0xf8,
5256         0x8c, 0xda, 0xec, 0xd3, 0xd8, 0xb2, 0xf7, 0x5d, 0xe9, 0x64, 0xf5, 0xd3, 0x02, 0x38, 0x5c, 0xe8,
5257         0x04, 0xfd, 0x00, 0x16, 0xf9, 0xc0, 0x6c, 0xe8, 0x94, 0x73, 0x6f, 0x19, 0x58, 0x2b, 0x12, 0x68,
5258         0xf1, 0x38, 0x16, 0xe1, 0xa4, 0x1e, 0x7a, 0x04, 0x2b, 0xae, 0x33, 0x38, 0x20, 0x36, 0x19, 0x52,
5259         0x3e, 0x66, 0x1c, 0x39, 0xa6, 0xa1, 0x4f, 0x04, 0xb3, 0x59, 0xe8, 0xbd, 0x1b, 0x4e, 0xa6, 0x47,
5260         0x79, 0x95, 0x67, 0x9c, 0x22, 0xe4, 0x97, 0x45, 0x52, 0x17, 0x41, 0x22, 0x0f, 0x5a, 0x23, 0xd9,
5261         0xee, 0x25, 0xd1, 0x0b, 0xfe, 0x6f, 0xd9, 0xa9, 0x12, 0x61, 0xa7, 0x29, 0xcb, 0xb8, 0xfa, 0xa7,
5262         0xd7, 0x71, 0xc6, 0x43, 0x29, 0x71, 0x6b, 0xfe, 0x3f, 0xc4, 0x4d, 0xfd, 0x77, 0x1d, 0x6e, 0xe6,
5263         0x4a, 0x25, 0xfa, 0xf1, 0x05, 0x0c, 0xe7, 0xd6, 0x73, 0x63, 0x37, 0xb9, 0x01, 0x7d, 0xf6, 0x0a,
5264         0x03, 0xfa, 0x2e, 0x2c, 0xeb, 0x23, 0xcf, 0xa3, 0x36, 0xcb, 0xb0, 0x9a, 0x88, 0x1a, 0xed, 0xa5,
5265         0xc5, 0x38, 0xab, 0x5f, 0xc4, 0xae, 0x1a, 0x57, 0x64, 0x57, 0xc9, 0x5d, 0xc8, 0x09, 0x39, 0x08,
5266         0xbb, 0xfc, 0x2e, 0xe4, 0xa0, 0x9c, 0xd5, 0xe7, 0xd3, 0x41, 0x80, 0x1a, 0x21, 0xcc, 0xa7, 0xa7,
5267         0x83, 0xd3, 0x94, 0x14, 0x67, 0xb4, 0x0b, 0x98, 0xca, 0x42, 0x55, 0xa6, 0x82, 0x48, 0x8a, 0x84,
5268         0x81, 0xc8, 0xf1, 0xed, 0x2a, 0xb1, 0x5c, 0x99, 0x85, 0xa9, 0x7f, 0x53, 0xe0, 0xc5, 0xd2, 0x24,
5269         0x40, 0xbb, 0xa9, 0x96, 0xbb, 0x9d, 0x69, 0xb9, 0xdf, 0x2b, 0x35, 0x4c, 0xf4, 0x5d, 0xaf, 0x98,
5270         0x1a, 0xbd, 0x5f, 0x8d, 0x1a, 0x15, 0xcc, 0xed, 0x97, 0x73, 0xa4, 0xde, 0xf6, 0x93, 0xa7, 0x9d,
5271         0x99, 0xaf, 0x9e, 0x76, 0x66, 0xbe, 0x7e, 0xda, 0x99, 0xf9, 0xcd, 0xb4, 0xa3, 0x3c, 0x99, 0x76,
5272         0x94, 0xaf, 0xa6, 0x1d, 0xe5, 0xeb, 0x69, 0x47, 0xf9, 0xc7, 0xb4, 0xa3, 0xfc, 0xee, 0x9b, 0xce,
5273         0xcc, 0x67, 0xf3, 0xd2, 0xe3, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe9, 0x89, 0x29, 0x5c, 0x61,
5274         0x1b, 0x00, 0x00,
5275 }