cmd/bpa-operator/vendor/k8s.io/api/extensions/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/extensions/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/extensions/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 AllowedFlexVolume
  28                 AllowedHostPath
  29                 DaemonSet
  30                 DaemonSetCondition
  31                 DaemonSetList
  32                 DaemonSetSpec
  33                 DaemonSetStatus
  34                 DaemonSetUpdateStrategy
  35                 Deployment
  36                 DeploymentCondition
  37                 DeploymentList
  38                 DeploymentRollback
  39                 DeploymentSpec
  40                 DeploymentStatus
  41                 DeploymentStrategy
  42                 FSGroupStrategyOptions
  43                 HTTPIngressPath
  44                 HTTPIngressRuleValue
  45                 HostPortRange
  46                 IDRange
  47                 IPBlock
  48                 Ingress
  49                 IngressBackend
  50                 IngressList
  51                 IngressRule
  52                 IngressRuleValue
  53                 IngressSpec
  54                 IngressStatus
  55                 IngressTLS
  56                 NetworkPolicy
  57                 NetworkPolicyEgressRule
  58                 NetworkPolicyIngressRule
  59                 NetworkPolicyList
  60                 NetworkPolicyPeer
  61                 NetworkPolicyPort
  62                 NetworkPolicySpec
  63                 PodSecurityPolicy
  64                 PodSecurityPolicyList
  65                 PodSecurityPolicySpec
  66                 ReplicaSet
  67                 ReplicaSetCondition
  68                 ReplicaSetList
  69                 ReplicaSetSpec
  70                 ReplicaSetStatus
  71                 ReplicationControllerDummy
  72                 RollbackConfig
  73                 RollingUpdateDaemonSet
  74                 RollingUpdateDeployment
  75                 RunAsGroupStrategyOptions
  76                 RunAsUserStrategyOptions
  77                 SELinuxStrategyOptions
  78                 Scale
  79                 ScaleSpec
  80                 ScaleStatus
  81                 SupplementalGroupsStrategyOptions
  82 */
  83 package v1beta1
  84
  85 import proto "github.com/gogo/protobuf/proto"
  86 import fmt "fmt"
  87 import math "math"
  88
  89 import k8s_io_api_core_v1 "k8s.io/api/core/v1"
  90 import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  91
  92 import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr"
  93
  94 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  95
  96 import strings "strings"
  97 import reflect "reflect"
  98
  99 import io "io"
 100
 101 // Reference imports to suppress errors if they are not otherwise used.
 102 var _ = proto.Marshal
 103 var _ = fmt.Errorf
 104 var _ = math.Inf
 105
 106 // This is a compile-time assertion to ensure that this generated file
 107 // is compatible with the proto package it is being compiled against.
 108 // A compilation error at this line likely means your copy of the
 109 // proto package needs to be updated.
 110 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 111
 112 func (m *AllowedFlexVolume) Reset()                    { *m = AllowedFlexVolume{} }
 113 func (*AllowedFlexVolume) ProtoMessage()               {}
 114 func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
 115
 116 func (m *AllowedHostPath) Reset()                    { *m = AllowedHostPath{} }
 117 func (*AllowedHostPath) ProtoMessage()               {}
 118 func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
 119
 120 func (m *DaemonSet) Reset()                    { *m = DaemonSet{} }
 121 func (*DaemonSet) ProtoMessage()               {}
 122 func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
 123
 124 func (m *DaemonSetCondition) Reset()                    { *m = DaemonSetCondition{} }
 125 func (*DaemonSetCondition) ProtoMessage()               {}
 126 func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
 127
 128 func (m *DaemonSetList) Reset()                    { *m = DaemonSetList{} }
 129 func (*DaemonSetList) ProtoMessage()               {}
 130 func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
 131
 132 func (m *DaemonSetSpec) Reset()                    { *m = DaemonSetSpec{} }
 133 func (*DaemonSetSpec) ProtoMessage()               {}
 134 func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
 135
 136 func (m *DaemonSetStatus) Reset()                    { *m = DaemonSetStatus{} }
 137 func (*DaemonSetStatus) ProtoMessage()               {}
 138 func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
 139
 140 func (m *DaemonSetUpdateStrategy) Reset()                    { *m = DaemonSetUpdateStrategy{} }
 141 func (*DaemonSetUpdateStrategy) ProtoMessage()               {}
 142 func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
 143
 144 func (m *Deployment) Reset()                    { *m = Deployment{} }
 145 func (*Deployment) ProtoMessage()               {}
 146 func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
 147
 148 func (m *DeploymentCondition) Reset()                    { *m = DeploymentCondition{} }
 149 func (*DeploymentCondition) ProtoMessage()               {}
 150 func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
 151
 152 func (m *DeploymentList) Reset()                    { *m = DeploymentList{} }
 153 func (*DeploymentList) ProtoMessage()               {}
 154 func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
 155
 156 func (m *DeploymentRollback) Reset()                    { *m = DeploymentRollback{} }
 157 func (*DeploymentRollback) ProtoMessage()               {}
 158 func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
 159
 160 func (m *DeploymentSpec) Reset()                    { *m = DeploymentSpec{} }
 161 func (*DeploymentSpec) ProtoMessage()               {}
 162 func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
 163
 164 func (m *DeploymentStatus) Reset()                    { *m = DeploymentStatus{} }
 165 func (*DeploymentStatus) ProtoMessage()               {}
 166 func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
 167
 168 func (m *DeploymentStrategy) Reset()                    { *m = DeploymentStrategy{} }
 169 func (*DeploymentStrategy) ProtoMessage()               {}
 170 func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
 171
 172 func (m *FSGroupStrategyOptions) Reset()                    { *m = FSGroupStrategyOptions{} }
 173 func (*FSGroupStrategyOptions) ProtoMessage()               {}
 174 func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
 175
 176 func (m *HTTPIngressPath) Reset()                    { *m = HTTPIngressPath{} }
 177 func (*HTTPIngressPath) ProtoMessage()               {}
 178 func (*HTTPIngressPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
 179
 180 func (m *HTTPIngressRuleValue) Reset()                    { *m = HTTPIngressRuleValue{} }
 181 func (*HTTPIngressRuleValue) ProtoMessage()               {}
 182 func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
 183
 184 func (m *HostPortRange) Reset()                    { *m = HostPortRange{} }
 185 func (*HostPortRange) ProtoMessage()               {}
 186 func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
 187
 188 func (m *IDRange) Reset()                    { *m = IDRange{} }
 189 func (*IDRange) ProtoMessage()               {}
 190 func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
 191
 192 func (m *IPBlock) Reset()                    { *m = IPBlock{} }
 193 func (*IPBlock) ProtoMessage()               {}
 194 func (*IPBlock) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
 195
 196 func (m *Ingress) Reset()                    { *m = Ingress{} }
 197 func (*Ingress) ProtoMessage()               {}
 198 func (*Ingress) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
 199
 200 func (m *IngressBackend) Reset()                    { *m = IngressBackend{} }
 201 func (*IngressBackend) ProtoMessage()               {}
 202 func (*IngressBackend) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
 203
 204 func (m *IngressList) Reset()                    { *m = IngressList{} }
 205 func (*IngressList) ProtoMessage()               {}
 206 func (*IngressList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
 207
 208 func (m *IngressRule) Reset()                    { *m = IngressRule{} }
 209 func (*IngressRule) ProtoMessage()               {}
 210 func (*IngressRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
 211
 212 func (m *IngressRuleValue) Reset()                    { *m = IngressRuleValue{} }
 213 func (*IngressRuleValue) ProtoMessage()               {}
 214 func (*IngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
 215
 216 func (m *IngressSpec) Reset()                    { *m = IngressSpec{} }
 217 func (*IngressSpec) ProtoMessage()               {}
 218 func (*IngressSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
 219
 220 func (m *IngressStatus) Reset()                    { *m = IngressStatus{} }
 221 func (*IngressStatus) ProtoMessage()               {}
 222 func (*IngressStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
 223
 224 func (m *IngressTLS) Reset()                    { *m = IngressTLS{} }
 225 func (*IngressTLS) ProtoMessage()               {}
 226 func (*IngressTLS) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
 227
 228 func (m *NetworkPolicy) Reset()                    { *m = NetworkPolicy{} }
 229 func (*NetworkPolicy) ProtoMessage()               {}
 230 func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} }
 231
 232 func (m *NetworkPolicyEgressRule) Reset()      { *m = NetworkPolicyEgressRule{} }
 233 func (*NetworkPolicyEgressRule) ProtoMessage() {}
 234 func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) {
 235         return fileDescriptorGenerated, []int{30}
 236 }
 237
 238 func (m *NetworkPolicyIngressRule) Reset()      { *m = NetworkPolicyIngressRule{} }
 239 func (*NetworkPolicyIngressRule) ProtoMessage() {}
 240 func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) {
 241         return fileDescriptorGenerated, []int{31}
 242 }
 243
 244 func (m *NetworkPolicyList) Reset()                    { *m = NetworkPolicyList{} }
 245 func (*NetworkPolicyList) ProtoMessage()               {}
 246 func (*NetworkPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} }
 247
 248 func (m *NetworkPolicyPeer) Reset()                    { *m = NetworkPolicyPeer{} }
 249 func (*NetworkPolicyPeer) ProtoMessage()               {}
 250 func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
 251
 252 func (m *NetworkPolicyPort) Reset()                    { *m = NetworkPolicyPort{} }
 253 func (*NetworkPolicyPort) ProtoMessage()               {}
 254 func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
 255
 256 func (m *NetworkPolicySpec) Reset()                    { *m = NetworkPolicySpec{} }
 257 func (*NetworkPolicySpec) ProtoMessage()               {}
 258 func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
 259
 260 func (m *PodSecurityPolicy) Reset()                    { *m = PodSecurityPolicy{} }
 261 func (*PodSecurityPolicy) ProtoMessage()               {}
 262 func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
 263
 264 func (m *PodSecurityPolicyList) Reset()                    { *m = PodSecurityPolicyList{} }
 265 func (*PodSecurityPolicyList) ProtoMessage()               {}
 266 func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
 267
 268 func (m *PodSecurityPolicySpec) Reset()                    { *m = PodSecurityPolicySpec{} }
 269 func (*PodSecurityPolicySpec) ProtoMessage()               {}
 270 func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
 271
 272 func (m *ReplicaSet) Reset()                    { *m = ReplicaSet{} }
 273 func (*ReplicaSet) ProtoMessage()               {}
 274 func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} }
 275
 276 func (m *ReplicaSetCondition) Reset()                    { *m = ReplicaSetCondition{} }
 277 func (*ReplicaSetCondition) ProtoMessage()               {}
 278 func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} }
 279
 280 func (m *ReplicaSetList) Reset()                    { *m = ReplicaSetList{} }
 281 func (*ReplicaSetList) ProtoMessage()               {}
 282 func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} }
 283
 284 func (m *ReplicaSetSpec) Reset()                    { *m = ReplicaSetSpec{} }
 285 func (*ReplicaSetSpec) ProtoMessage()               {}
 286 func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} }
 287
 288 func (m *ReplicaSetStatus) Reset()                    { *m = ReplicaSetStatus{} }
 289 func (*ReplicaSetStatus) ProtoMessage()               {}
 290 func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} }
 291
 292 func (m *ReplicationControllerDummy) Reset()      { *m = ReplicationControllerDummy{} }
 293 func (*ReplicationControllerDummy) ProtoMessage() {}
 294 func (*ReplicationControllerDummy) Descriptor() ([]byte, []int) {
 295         return fileDescriptorGenerated, []int{44}
 296 }
 297
 298 func (m *RollbackConfig) Reset()                    { *m = RollbackConfig{} }
 299 func (*RollbackConfig) ProtoMessage()               {}
 300 func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{45} }
 301
 302 func (m *RollingUpdateDaemonSet) Reset()                    { *m = RollingUpdateDaemonSet{} }
 303 func (*RollingUpdateDaemonSet) ProtoMessage()               {}
 304 func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{46} }
 305
 306 func (m *RollingUpdateDeployment) Reset()      { *m = RollingUpdateDeployment{} }
 307 func (*RollingUpdateDeployment) ProtoMessage() {}
 308 func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
 309         return fileDescriptorGenerated, []int{47}
 310 }
 311
 312 func (m *RunAsGroupStrategyOptions) Reset()      { *m = RunAsGroupStrategyOptions{} }
 313 func (*RunAsGroupStrategyOptions) ProtoMessage() {}
 314 func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) {
 315         return fileDescriptorGenerated, []int{48}
 316 }
 317
 318 func (m *RunAsUserStrategyOptions) Reset()      { *m = RunAsUserStrategyOptions{} }
 319 func (*RunAsUserStrategyOptions) ProtoMessage() {}
 320 func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) {
 321         return fileDescriptorGenerated, []int{49}
 322 }
 323
 324 func (m *SELinuxStrategyOptions) Reset()                    { *m = SELinuxStrategyOptions{} }
 325 func (*SELinuxStrategyOptions) ProtoMessage()               {}
 326 func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{50} }
 327
 328 func (m *Scale) Reset()                    { *m = Scale{} }
 329 func (*Scale) ProtoMessage()               {}
 330 func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{51} }
 331
 332 func (m *ScaleSpec) Reset()                    { *m = ScaleSpec{} }
 333 func (*ScaleSpec) ProtoMessage()               {}
 334 func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{52} }
 335
 336 func (m *ScaleStatus) Reset()                    { *m = ScaleStatus{} }
 337 func (*ScaleStatus) ProtoMessage()               {}
 338 func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{53} }
 339
 340 func (m *SupplementalGroupsStrategyOptions) Reset()      { *m = SupplementalGroupsStrategyOptions{} }
 341 func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
 342 func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) {
 343         return fileDescriptorGenerated, []int{54}
 344 }
 345
 346 func init() {
 347         proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.extensions.v1beta1.AllowedFlexVolume")
 348         proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.extensions.v1beta1.AllowedHostPath")
 349         proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet")
 350         proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition")
 351         proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList")
 352         proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec")
 353         proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus")
 354         proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy")
 355         proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment")
 356         proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition")
 357         proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList")
 358         proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback")
 359         proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec")
 360         proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus")
 361         proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy")
 362         proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.FSGroupStrategyOptions")
 363         proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath")
 364         proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue")
 365         proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.extensions.v1beta1.HostPortRange")
 366         proto.RegisterType((*IDRange)(nil), "k8s.io.api.extensions.v1beta1.IDRange")
 367         proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock")
 368         proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress")
 369         proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend")
 370         proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList")
 371         proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule")
 372         proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue")
 373         proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec")
 374         proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus")
 375         proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS")
 376         proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy")
 377         proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule")
 378         proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule")
 379         proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList")
 380         proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer")
 381         proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort")
 382         proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec")
 383         proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicy")
 384         proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicyList")
 385         proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicySpec")
 386         proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet")
 387         proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition")
 388         proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList")
 389         proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec")
 390         proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus")
 391         proto.RegisterType((*ReplicationControllerDummy)(nil), "k8s.io.api.extensions.v1beta1.ReplicationControllerDummy")
 392         proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig")
 393         proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet")
 394         proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment")
 395         proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsGroupStrategyOptions")
 396         proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsUserStrategyOptions")
 397         proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SELinuxStrategyOptions")
 398         proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale")
 399         proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec")
 400         proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus")
 401         proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SupplementalGroupsStrategyOptions")
 402 }
 403 func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) {
 404         size := m.Size()
 405         dAtA = make([]byte, size)
 406         n, err := m.MarshalTo(dAtA)
 407         if err != nil {
 408                 return nil, err
 409         }
 410         return dAtA[:n], nil
 411 }
 412
 413 func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) {
 414         var i int
 415         _ = i
 416         var l int
 417         _ = l
 418         dAtA[i] = 0xa
 419         i++
 420         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
 421         i += copy(dAtA[i:], m.Driver)
 422         return i, nil
 423 }
 424
 425 func (m *AllowedHostPath) Marshal() (dAtA []byte, err error) {
 426         size := m.Size()
 427         dAtA = make([]byte, size)
 428         n, err := m.MarshalTo(dAtA)
 429         if err != nil {
 430                 return nil, err
 431         }
 432         return dAtA[:n], nil
 433 }
 434
 435 func (m *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) {
 436         var i int
 437         _ = i
 438         var l int
 439         _ = l
 440         dAtA[i] = 0xa
 441         i++
 442         i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix)))
 443         i += copy(dAtA[i:], m.PathPrefix)
 444         dAtA[i] = 0x10
 445         i++
 446         if m.ReadOnly {
 447                 dAtA[i] = 1
 448         } else {
 449                 dAtA[i] = 0
 450         }
 451         i++
 452         return i, nil
 453 }
 454
 455 func (m *DaemonSet) Marshal() (dAtA []byte, err error) {
 456         size := m.Size()
 457         dAtA = make([]byte, size)
 458         n, err := m.MarshalTo(dAtA)
 459         if err != nil {
 460                 return nil, err
 461         }
 462         return dAtA[:n], nil
 463 }
 464
 465 func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) {
 466         var i int
 467         _ = i
 468         var l int
 469         _ = l
 470         dAtA[i] = 0xa
 471         i++
 472         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 473         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 474         if err != nil {
 475                 return 0, err
 476         }
 477         i += n1
 478         dAtA[i] = 0x12
 479         i++
 480         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 481         n2, err := m.Spec.MarshalTo(dAtA[i:])
 482         if err != nil {
 483                 return 0, err
 484         }
 485         i += n2
 486         dAtA[i] = 0x1a
 487         i++
 488         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 489         n3, err := m.Status.MarshalTo(dAtA[i:])
 490         if err != nil {
 491                 return 0, err
 492         }
 493         i += n3
 494         return i, nil
 495 }
 496
 497 func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) {
 498         size := m.Size()
 499         dAtA = make([]byte, size)
 500         n, err := m.MarshalTo(dAtA)
 501         if err != nil {
 502                 return nil, err
 503         }
 504         return dAtA[:n], nil
 505 }
 506
 507 func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) {
 508         var i int
 509         _ = i
 510         var l int
 511         _ = l
 512         dAtA[i] = 0xa
 513         i++
 514         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 515         i += copy(dAtA[i:], m.Type)
 516         dAtA[i] = 0x12
 517         i++
 518         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
 519         i += copy(dAtA[i:], m.Status)
 520         dAtA[i] = 0x1a
 521         i++
 522         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
 523         n4, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
 524         if err != nil {
 525                 return 0, err
 526         }
 527         i += n4
 528         dAtA[i] = 0x22
 529         i++
 530         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 531         i += copy(dAtA[i:], m.Reason)
 532         dAtA[i] = 0x2a
 533         i++
 534         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 535         i += copy(dAtA[i:], m.Message)
 536         return i, nil
 537 }
 538
 539 func (m *DaemonSetList) Marshal() (dAtA []byte, err error) {
 540         size := m.Size()
 541         dAtA = make([]byte, size)
 542         n, err := m.MarshalTo(dAtA)
 543         if err != nil {
 544                 return nil, err
 545         }
 546         return dAtA[:n], nil
 547 }
 548
 549 func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) {
 550         var i int
 551         _ = i
 552         var l int
 553         _ = l
 554         dAtA[i] = 0xa
 555         i++
 556         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 557         n5, err := m.ListMeta.MarshalTo(dAtA[i:])
 558         if err != nil {
 559                 return 0, err
 560         }
 561         i += n5
 562         if len(m.Items) > 0 {
 563                 for _, msg := range m.Items {
 564                         dAtA[i] = 0x12
 565                         i++
 566                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 567                         n, err := msg.MarshalTo(dAtA[i:])
 568                         if err != nil {
 569                                 return 0, err
 570                         }
 571                         i += n
 572                 }
 573         }
 574         return i, nil
 575 }
 576
 577 func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) {
 578         size := m.Size()
 579         dAtA = make([]byte, size)
 580         n, err := m.MarshalTo(dAtA)
 581         if err != nil {
 582                 return nil, err
 583         }
 584         return dAtA[:n], nil
 585 }
 586
 587 func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) {
 588         var i int
 589         _ = i
 590         var l int
 591         _ = l
 592         if m.Selector != nil {
 593                 dAtA[i] = 0xa
 594                 i++
 595                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 596                 n6, err := m.Selector.MarshalTo(dAtA[i:])
 597                 if err != nil {
 598                         return 0, err
 599                 }
 600                 i += n6
 601         }
 602         dAtA[i] = 0x12
 603         i++
 604         i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
 605         n7, err := m.Template.MarshalTo(dAtA[i:])
 606         if err != nil {
 607                 return 0, err
 608         }
 609         i += n7
 610         dAtA[i] = 0x1a
 611         i++
 612         i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size()))
 613         n8, err := m.UpdateStrategy.MarshalTo(dAtA[i:])
 614         if err != nil {
 615                 return 0, err
 616         }
 617         i += n8
 618         dAtA[i] = 0x20
 619         i++
 620         i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
 621         dAtA[i] = 0x28
 622         i++
 623         i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration))
 624         if m.RevisionHistoryLimit != nil {
 625                 dAtA[i] = 0x30
 626                 i++
 627                 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
 628         }
 629         return i, nil
 630 }
 631
 632 func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) {
 633         size := m.Size()
 634         dAtA = make([]byte, size)
 635         n, err := m.MarshalTo(dAtA)
 636         if err != nil {
 637                 return nil, err
 638         }
 639         return dAtA[:n], nil
 640 }
 641
 642 func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) {
 643         var i int
 644         _ = i
 645         var l int
 646         _ = l
 647         dAtA[i] = 0x8
 648         i++
 649         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled))
 650         dAtA[i] = 0x10
 651         i++
 652         i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled))
 653         dAtA[i] = 0x18
 654         i++
 655         i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled))
 656         dAtA[i] = 0x20
 657         i++
 658         i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady))
 659         dAtA[i] = 0x28
 660         i++
 661         i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
 662         dAtA[i] = 0x30
 663         i++
 664         i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled))
 665         dAtA[i] = 0x38
 666         i++
 667         i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable))
 668         dAtA[i] = 0x40
 669         i++
 670         i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable))
 671         if m.CollisionCount != nil {
 672                 dAtA[i] = 0x48
 673                 i++
 674                 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
 675         }
 676         if len(m.Conditions) > 0 {
 677                 for _, msg := range m.Conditions {
 678                         dAtA[i] = 0x52
 679                         i++
 680                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 681                         n, err := msg.MarshalTo(dAtA[i:])
 682                         if err != nil {
 683                                 return 0, err
 684                         }
 685                         i += n
 686                 }
 687         }
 688         return i, nil
 689 }
 690
 691 func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
 692         size := m.Size()
 693         dAtA = make([]byte, size)
 694         n, err := m.MarshalTo(dAtA)
 695         if err != nil {
 696                 return nil, err
 697         }
 698         return dAtA[:n], nil
 699 }
 700
 701 func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
 702         var i int
 703         _ = i
 704         var l int
 705         _ = l
 706         dAtA[i] = 0xa
 707         i++
 708         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 709         i += copy(dAtA[i:], m.Type)
 710         if m.RollingUpdate != nil {
 711                 dAtA[i] = 0x12
 712                 i++
 713                 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
 714                 n9, err := m.RollingUpdate.MarshalTo(dAtA[i:])
 715                 if err != nil {
 716                         return 0, err
 717                 }
 718                 i += n9
 719         }
 720         return i, nil
 721 }
 722
 723 func (m *Deployment) Marshal() (dAtA []byte, err error) {
 724         size := m.Size()
 725         dAtA = make([]byte, size)
 726         n, err := m.MarshalTo(dAtA)
 727         if err != nil {
 728                 return nil, err
 729         }
 730         return dAtA[:n], nil
 731 }
 732
 733 func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
 734         var i int
 735         _ = i
 736         var l int
 737         _ = l
 738         dAtA[i] = 0xa
 739         i++
 740         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 741         n10, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 742         if err != nil {
 743                 return 0, err
 744         }
 745         i += n10
 746         dAtA[i] = 0x12
 747         i++
 748         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 749         n11, err := m.Spec.MarshalTo(dAtA[i:])
 750         if err != nil {
 751                 return 0, err
 752         }
 753         i += n11
 754         dAtA[i] = 0x1a
 755         i++
 756         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 757         n12, err := m.Status.MarshalTo(dAtA[i:])
 758         if err != nil {
 759                 return 0, err
 760         }
 761         i += n12
 762         return i, nil
 763 }
 764
 765 func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
 766         size := m.Size()
 767         dAtA = make([]byte, size)
 768         n, err := m.MarshalTo(dAtA)
 769         if err != nil {
 770                 return nil, err
 771         }
 772         return dAtA[:n], nil
 773 }
 774
 775 func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
 776         var i int
 777         _ = i
 778         var l int
 779         _ = l
 780         dAtA[i] = 0xa
 781         i++
 782         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 783         i += copy(dAtA[i:], m.Type)
 784         dAtA[i] = 0x12
 785         i++
 786         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
 787         i += copy(dAtA[i:], m.Status)
 788         dAtA[i] = 0x22
 789         i++
 790         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 791         i += copy(dAtA[i:], m.Reason)
 792         dAtA[i] = 0x2a
 793         i++
 794         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 795         i += copy(dAtA[i:], m.Message)
 796         dAtA[i] = 0x32
 797         i++
 798         i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
 799         n13, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
 800         if err != nil {
 801                 return 0, err
 802         }
 803         i += n13
 804         dAtA[i] = 0x3a
 805         i++
 806         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
 807         n14, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
 808         if err != nil {
 809                 return 0, err
 810         }
 811         i += n14
 812         return i, nil
 813 }
 814
 815 func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
 816         size := m.Size()
 817         dAtA = make([]byte, size)
 818         n, err := m.MarshalTo(dAtA)
 819         if err != nil {
 820                 return nil, err
 821         }
 822         return dAtA[:n], nil
 823 }
 824
 825 func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
 826         var i int
 827         _ = i
 828         var l int
 829         _ = l
 830         dAtA[i] = 0xa
 831         i++
 832         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 833         n15, err := m.ListMeta.MarshalTo(dAtA[i:])
 834         if err != nil {
 835                 return 0, err
 836         }
 837         i += n15
 838         if len(m.Items) > 0 {
 839                 for _, msg := range m.Items {
 840                         dAtA[i] = 0x12
 841                         i++
 842                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 843                         n, err := msg.MarshalTo(dAtA[i:])
 844                         if err != nil {
 845                                 return 0, err
 846                         }
 847                         i += n
 848                 }
 849         }
 850         return i, nil
 851 }
 852
 853 func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) {
 854         size := m.Size()
 855         dAtA = make([]byte, size)
 856         n, err := m.MarshalTo(dAtA)
 857         if err != nil {
 858                 return nil, err
 859         }
 860         return dAtA[:n], nil
 861 }
 862
 863 func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) {
 864         var i int
 865         _ = i
 866         var l int
 867         _ = l
 868         dAtA[i] = 0xa
 869         i++
 870         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 871         i += copy(dAtA[i:], m.Name)
 872         if len(m.UpdatedAnnotations) > 0 {
 873                 keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations))
 874                 for k := range m.UpdatedAnnotations {
 875                         keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k))
 876                 }
 877                 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
 878                 for _, k := range keysForUpdatedAnnotations {
 879                         dAtA[i] = 0x12
 880                         i++
 881                         v := m.UpdatedAnnotations[string(k)]
 882                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 883                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 884                         dAtA[i] = 0xa
 885                         i++
 886                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 887                         i += copy(dAtA[i:], k)
 888                         dAtA[i] = 0x12
 889                         i++
 890                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
 891                         i += copy(dAtA[i:], v)
 892                 }
 893         }
 894         dAtA[i] = 0x1a
 895         i++
 896         i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
 897         n16, err := m.RollbackTo.MarshalTo(dAtA[i:])
 898         if err != nil {
 899                 return 0, err
 900         }
 901         i += n16
 902         return i, nil
 903 }
 904
 905 func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
 906         size := m.Size()
 907         dAtA = make([]byte, size)
 908         n, err := m.MarshalTo(dAtA)
 909         if err != nil {
 910                 return nil, err
 911         }
 912         return dAtA[:n], nil
 913 }
 914
 915 func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
 916         var i int
 917         _ = i
 918         var l int
 919         _ = l
 920         if m.Replicas != nil {
 921                 dAtA[i] = 0x8
 922                 i++
 923                 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
 924         }
 925         if m.Selector != nil {
 926                 dAtA[i] = 0x12
 927                 i++
 928                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 929                 n17, err := m.Selector.MarshalTo(dAtA[i:])
 930                 if err != nil {
 931                         return 0, err
 932                 }
 933                 i += n17
 934         }
 935         dAtA[i] = 0x1a
 936         i++
 937         i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
 938         n18, err := m.Template.MarshalTo(dAtA[i:])
 939         if err != nil {
 940                 return 0, err
 941         }
 942         i += n18
 943         dAtA[i] = 0x22
 944         i++
 945         i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size()))
 946         n19, err := m.Strategy.MarshalTo(dAtA[i:])
 947         if err != nil {
 948                 return 0, err
 949         }
 950         i += n19
 951         dAtA[i] = 0x28
 952         i++
 953         i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
 954         if m.RevisionHistoryLimit != nil {
 955                 dAtA[i] = 0x30
 956                 i++
 957                 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
 958         }
 959         dAtA[i] = 0x38
 960         i++
 961         if m.Paused {
 962                 dAtA[i] = 1
 963         } else {
 964                 dAtA[i] = 0
 965         }
 966         i++
 967         if m.RollbackTo != nil {
 968                 dAtA[i] = 0x42
 969                 i++
 970                 i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
 971                 n20, err := m.RollbackTo.MarshalTo(dAtA[i:])
 972                 if err != nil {
 973                         return 0, err
 974                 }
 975                 i += n20
 976         }
 977         if m.ProgressDeadlineSeconds != nil {
 978                 dAtA[i] = 0x48
 979                 i++
 980                 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
 981         }
 982         return i, nil
 983 }
 984
 985 func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
 986         size := m.Size()
 987         dAtA = make([]byte, size)
 988         n, err := m.MarshalTo(dAtA)
 989         if err != nil {
 990                 return nil, err
 991         }
 992         return dAtA[:n], nil
 993 }
 994
 995 func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
 996         var i int
 997         _ = i
 998         var l int
 999         _ = l
1000         dAtA[i] = 0x8
1001         i++
1002         i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1003         dAtA[i] = 0x10
1004         i++
1005         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1006         dAtA[i] = 0x18
1007         i++
1008         i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1009         dAtA[i] = 0x20
1010         i++
1011         i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1012         dAtA[i] = 0x28
1013         i++
1014         i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
1015         if len(m.Conditions) > 0 {
1016                 for _, msg := range m.Conditions {
1017                         dAtA[i] = 0x32
1018                         i++
1019                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1020                         n, err := msg.MarshalTo(dAtA[i:])
1021                         if err != nil {
1022                                 return 0, err
1023                         }
1024                         i += n
1025                 }
1026         }
1027         dAtA[i] = 0x38
1028         i++
1029         i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1030         if m.CollisionCount != nil {
1031                 dAtA[i] = 0x40
1032                 i++
1033                 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1034         }
1035         return i, nil
1036 }
1037
1038 func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
1039         size := m.Size()
1040         dAtA = make([]byte, size)
1041         n, err := m.MarshalTo(dAtA)
1042         if err != nil {
1043                 return nil, err
1044         }
1045         return dAtA[:n], nil
1046 }
1047
1048 func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
1049         var i int
1050         _ = i
1051         var l int
1052         _ = l
1053         dAtA[i] = 0xa
1054         i++
1055         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1056         i += copy(dAtA[i:], m.Type)
1057         if m.RollingUpdate != nil {
1058                 dAtA[i] = 0x12
1059                 i++
1060                 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
1061                 n21, err := m.RollingUpdate.MarshalTo(dAtA[i:])
1062                 if err != nil {
1063                         return 0, err
1064                 }
1065                 i += n21
1066         }
1067         return i, nil
1068 }
1069
1070 func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
1071         size := m.Size()
1072         dAtA = make([]byte, size)
1073         n, err := m.MarshalTo(dAtA)
1074         if err != nil {
1075                 return nil, err
1076         }
1077         return dAtA[:n], nil
1078 }
1079
1080 func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
1081         var i int
1082         _ = i
1083         var l int
1084         _ = l
1085         dAtA[i] = 0xa
1086         i++
1087         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
1088         i += copy(dAtA[i:], m.Rule)
1089         if len(m.Ranges) > 0 {
1090                 for _, msg := range m.Ranges {
1091                         dAtA[i] = 0x12
1092                         i++
1093                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1094                         n, err := msg.MarshalTo(dAtA[i:])
1095                         if err != nil {
1096                                 return 0, err
1097                         }
1098                         i += n
1099                 }
1100         }
1101         return i, nil
1102 }
1103
1104 func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) {
1105         size := m.Size()
1106         dAtA = make([]byte, size)
1107         n, err := m.MarshalTo(dAtA)
1108         if err != nil {
1109                 return nil, err
1110         }
1111         return dAtA[:n], nil
1112 }
1113
1114 func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) {
1115         var i int
1116         _ = i
1117         var l int
1118         _ = l
1119         dAtA[i] = 0xa
1120         i++
1121         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
1122         i += copy(dAtA[i:], m.Path)
1123         dAtA[i] = 0x12
1124         i++
1125         i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size()))
1126         n22, err := m.Backend.MarshalTo(dAtA[i:])
1127         if err != nil {
1128                 return 0, err
1129         }
1130         i += n22
1131         return i, nil
1132 }
1133
1134 func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) {
1135         size := m.Size()
1136         dAtA = make([]byte, size)
1137         n, err := m.MarshalTo(dAtA)
1138         if err != nil {
1139                 return nil, err
1140         }
1141         return dAtA[:n], nil
1142 }
1143
1144 func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
1145         var i int
1146         _ = i
1147         var l int
1148         _ = l
1149         if len(m.Paths) > 0 {
1150                 for _, msg := range m.Paths {
1151                         dAtA[i] = 0xa
1152                         i++
1153                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1154                         n, err := msg.MarshalTo(dAtA[i:])
1155                         if err != nil {
1156                                 return 0, err
1157                         }
1158                         i += n
1159                 }
1160         }
1161         return i, nil
1162 }
1163
1164 func (m *HostPortRange) Marshal() (dAtA []byte, err error) {
1165         size := m.Size()
1166         dAtA = make([]byte, size)
1167         n, err := m.MarshalTo(dAtA)
1168         if err != nil {
1169                 return nil, err
1170         }
1171         return dAtA[:n], nil
1172 }
1173
1174 func (m *HostPortRange) MarshalTo(dAtA []byte) (int, error) {
1175         var i int
1176         _ = i
1177         var l int
1178         _ = l
1179         dAtA[i] = 0x8
1180         i++
1181         i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
1182         dAtA[i] = 0x10
1183         i++
1184         i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
1185         return i, nil
1186 }
1187
1188 func (m *IDRange) Marshal() (dAtA []byte, err error) {
1189         size := m.Size()
1190         dAtA = make([]byte, size)
1191         n, err := m.MarshalTo(dAtA)
1192         if err != nil {
1193                 return nil, err
1194         }
1195         return dAtA[:n], nil
1196 }
1197
1198 func (m *IDRange) MarshalTo(dAtA []byte) (int, error) {
1199         var i int
1200         _ = i
1201         var l int
1202         _ = l
1203         dAtA[i] = 0x8
1204         i++
1205         i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
1206         dAtA[i] = 0x10
1207         i++
1208         i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
1209         return i, nil
1210 }
1211
1212 func (m *IPBlock) Marshal() (dAtA []byte, err error) {
1213         size := m.Size()
1214         dAtA = make([]byte, size)
1215         n, err := m.MarshalTo(dAtA)
1216         if err != nil {
1217                 return nil, err
1218         }
1219         return dAtA[:n], nil
1220 }
1221
1222 func (m *IPBlock) MarshalTo(dAtA []byte) (int, error) {
1223         var i int
1224         _ = i
1225         var l int
1226         _ = l
1227         dAtA[i] = 0xa
1228         i++
1229         i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR)))
1230         i += copy(dAtA[i:], m.CIDR)
1231         if len(m.Except) > 0 {
1232                 for _, s := range m.Except {
1233                         dAtA[i] = 0x12
1234                         i++
1235                         l = len(s)
1236                         for l >= 1<<7 {
1237                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1238                                 l >>= 7
1239                                 i++
1240                         }
1241                         dAtA[i] = uint8(l)
1242                         i++
1243                         i += copy(dAtA[i:], s)
1244                 }
1245         }
1246         return i, nil
1247 }
1248
1249 func (m *Ingress) Marshal() (dAtA []byte, err error) {
1250         size := m.Size()
1251         dAtA = make([]byte, size)
1252         n, err := m.MarshalTo(dAtA)
1253         if err != nil {
1254                 return nil, err
1255         }
1256         return dAtA[:n], nil
1257 }
1258
1259 func (m *Ingress) MarshalTo(dAtA []byte) (int, error) {
1260         var i int
1261         _ = i
1262         var l int
1263         _ = l
1264         dAtA[i] = 0xa
1265         i++
1266         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1267         n23, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1268         if err != nil {
1269                 return 0, err
1270         }
1271         i += n23
1272         dAtA[i] = 0x12
1273         i++
1274         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1275         n24, err := m.Spec.MarshalTo(dAtA[i:])
1276         if err != nil {
1277                 return 0, err
1278         }
1279         i += n24
1280         dAtA[i] = 0x1a
1281         i++
1282         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
1283         n25, err := m.Status.MarshalTo(dAtA[i:])
1284         if err != nil {
1285                 return 0, err
1286         }
1287         i += n25
1288         return i, nil
1289 }
1290
1291 func (m *IngressBackend) Marshal() (dAtA []byte, err error) {
1292         size := m.Size()
1293         dAtA = make([]byte, size)
1294         n, err := m.MarshalTo(dAtA)
1295         if err != nil {
1296                 return nil, err
1297         }
1298         return dAtA[:n], nil
1299 }
1300
1301 func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) {
1302         var i int
1303         _ = i
1304         var l int
1305         _ = l
1306         dAtA[i] = 0xa
1307         i++
1308         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
1309         i += copy(dAtA[i:], m.ServiceName)
1310         dAtA[i] = 0x12
1311         i++
1312         i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort.Size()))
1313         n26, err := m.ServicePort.MarshalTo(dAtA[i:])
1314         if err != nil {
1315                 return 0, err
1316         }
1317         i += n26
1318         return i, nil
1319 }
1320
1321 func (m *IngressList) Marshal() (dAtA []byte, err error) {
1322         size := m.Size()
1323         dAtA = make([]byte, size)
1324         n, err := m.MarshalTo(dAtA)
1325         if err != nil {
1326                 return nil, err
1327         }
1328         return dAtA[:n], nil
1329 }
1330
1331 func (m *IngressList) MarshalTo(dAtA []byte) (int, error) {
1332         var i int
1333         _ = i
1334         var l int
1335         _ = l
1336         dAtA[i] = 0xa
1337         i++
1338         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1339         n27, err := m.ListMeta.MarshalTo(dAtA[i:])
1340         if err != nil {
1341                 return 0, err
1342         }
1343         i += n27
1344         if len(m.Items) > 0 {
1345                 for _, msg := range m.Items {
1346                         dAtA[i] = 0x12
1347                         i++
1348                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1349                         n, err := msg.MarshalTo(dAtA[i:])
1350                         if err != nil {
1351                                 return 0, err
1352                         }
1353                         i += n
1354                 }
1355         }
1356         return i, nil
1357 }
1358
1359 func (m *IngressRule) Marshal() (dAtA []byte, err error) {
1360         size := m.Size()
1361         dAtA = make([]byte, size)
1362         n, err := m.MarshalTo(dAtA)
1363         if err != nil {
1364                 return nil, err
1365         }
1366         return dAtA[:n], nil
1367 }
1368
1369 func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) {
1370         var i int
1371         _ = i
1372         var l int
1373         _ = l
1374         dAtA[i] = 0xa
1375         i++
1376         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
1377         i += copy(dAtA[i:], m.Host)
1378         dAtA[i] = 0x12
1379         i++
1380         i = encodeVarintGenerated(dAtA, i, uint64(m.IngressRuleValue.Size()))
1381         n28, err := m.IngressRuleValue.MarshalTo(dAtA[i:])
1382         if err != nil {
1383                 return 0, err
1384         }
1385         i += n28
1386         return i, nil
1387 }
1388
1389 func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) {
1390         size := m.Size()
1391         dAtA = make([]byte, size)
1392         n, err := m.MarshalTo(dAtA)
1393         if err != nil {
1394                 return nil, err
1395         }
1396         return dAtA[:n], nil
1397 }
1398
1399 func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
1400         var i int
1401         _ = i
1402         var l int
1403         _ = l
1404         if m.HTTP != nil {
1405                 dAtA[i] = 0xa
1406                 i++
1407                 i = encodeVarintGenerated(dAtA, i, uint64(m.HTTP.Size()))
1408                 n29, err := m.HTTP.MarshalTo(dAtA[i:])
1409                 if err != nil {
1410                         return 0, err
1411                 }
1412                 i += n29
1413         }
1414         return i, nil
1415 }
1416
1417 func (m *IngressSpec) Marshal() (dAtA []byte, err error) {
1418         size := m.Size()
1419         dAtA = make([]byte, size)
1420         n, err := m.MarshalTo(dAtA)
1421         if err != nil {
1422                 return nil, err
1423         }
1424         return dAtA[:n], nil
1425 }
1426
1427 func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) {
1428         var i int
1429         _ = i
1430         var l int
1431         _ = l
1432         if m.Backend != nil {
1433                 dAtA[i] = 0xa
1434                 i++
1435                 i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size()))
1436                 n30, err := m.Backend.MarshalTo(dAtA[i:])
1437                 if err != nil {
1438                         return 0, err
1439                 }
1440                 i += n30
1441         }
1442         if len(m.TLS) > 0 {
1443                 for _, msg := range m.TLS {
1444                         dAtA[i] = 0x12
1445                         i++
1446                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1447                         n, err := msg.MarshalTo(dAtA[i:])
1448                         if err != nil {
1449                                 return 0, err
1450                         }
1451                         i += n
1452                 }
1453         }
1454         if len(m.Rules) > 0 {
1455                 for _, msg := range m.Rules {
1456                         dAtA[i] = 0x1a
1457                         i++
1458                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1459                         n, err := msg.MarshalTo(dAtA[i:])
1460                         if err != nil {
1461                                 return 0, err
1462                         }
1463                         i += n
1464                 }
1465         }
1466         return i, nil
1467 }
1468
1469 func (m *IngressStatus) Marshal() (dAtA []byte, err error) {
1470         size := m.Size()
1471         dAtA = make([]byte, size)
1472         n, err := m.MarshalTo(dAtA)
1473         if err != nil {
1474                 return nil, err
1475         }
1476         return dAtA[:n], nil
1477 }
1478
1479 func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) {
1480         var i int
1481         _ = i
1482         var l int
1483         _ = l
1484         dAtA[i] = 0xa
1485         i++
1486         i = encodeVarintGenerated(dAtA, i, uint64(m.LoadBalancer.Size()))
1487         n31, err := m.LoadBalancer.MarshalTo(dAtA[i:])
1488         if err != nil {
1489                 return 0, err
1490         }
1491         i += n31
1492         return i, nil
1493 }
1494
1495 func (m *IngressTLS) Marshal() (dAtA []byte, err error) {
1496         size := m.Size()
1497         dAtA = make([]byte, size)
1498         n, err := m.MarshalTo(dAtA)
1499         if err != nil {
1500                 return nil, err
1501         }
1502         return dAtA[:n], nil
1503 }
1504
1505 func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) {
1506         var i int
1507         _ = i
1508         var l int
1509         _ = l
1510         if len(m.Hosts) > 0 {
1511                 for _, s := range m.Hosts {
1512                         dAtA[i] = 0xa
1513                         i++
1514                         l = len(s)
1515                         for l >= 1<<7 {
1516                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1517                                 l >>= 7
1518                                 i++
1519                         }
1520                         dAtA[i] = uint8(l)
1521                         i++
1522                         i += copy(dAtA[i:], s)
1523                 }
1524         }
1525         dAtA[i] = 0x12
1526         i++
1527         i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName)))
1528         i += copy(dAtA[i:], m.SecretName)
1529         return i, nil
1530 }
1531
1532 func (m *NetworkPolicy) Marshal() (dAtA []byte, err error) {
1533         size := m.Size()
1534         dAtA = make([]byte, size)
1535         n, err := m.MarshalTo(dAtA)
1536         if err != nil {
1537                 return nil, err
1538         }
1539         return dAtA[:n], nil
1540 }
1541
1542 func (m *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) {
1543         var i int
1544         _ = i
1545         var l int
1546         _ = l
1547         dAtA[i] = 0xa
1548         i++
1549         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1550         n32, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1551         if err != nil {
1552                 return 0, err
1553         }
1554         i += n32
1555         dAtA[i] = 0x12
1556         i++
1557         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1558         n33, err := m.Spec.MarshalTo(dAtA[i:])
1559         if err != nil {
1560                 return 0, err
1561         }
1562         i += n33
1563         return i, nil
1564 }
1565
1566 func (m *NetworkPolicyEgressRule) Marshal() (dAtA []byte, err error) {
1567         size := m.Size()
1568         dAtA = make([]byte, size)
1569         n, err := m.MarshalTo(dAtA)
1570         if err != nil {
1571                 return nil, err
1572         }
1573         return dAtA[:n], nil
1574 }
1575
1576 func (m *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) {
1577         var i int
1578         _ = i
1579         var l int
1580         _ = l
1581         if len(m.Ports) > 0 {
1582                 for _, msg := range m.Ports {
1583                         dAtA[i] = 0xa
1584                         i++
1585                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1586                         n, err := msg.MarshalTo(dAtA[i:])
1587                         if err != nil {
1588                                 return 0, err
1589                         }
1590                         i += n
1591                 }
1592         }
1593         if len(m.To) > 0 {
1594                 for _, msg := range m.To {
1595                         dAtA[i] = 0x12
1596                         i++
1597                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1598                         n, err := msg.MarshalTo(dAtA[i:])
1599                         if err != nil {
1600                                 return 0, err
1601                         }
1602                         i += n
1603                 }
1604         }
1605         return i, nil
1606 }
1607
1608 func (m *NetworkPolicyIngressRule) Marshal() (dAtA []byte, err error) {
1609         size := m.Size()
1610         dAtA = make([]byte, size)
1611         n, err := m.MarshalTo(dAtA)
1612         if err != nil {
1613                 return nil, err
1614         }
1615         return dAtA[:n], nil
1616 }
1617
1618 func (m *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) {
1619         var i int
1620         _ = i
1621         var l int
1622         _ = l
1623         if len(m.Ports) > 0 {
1624                 for _, msg := range m.Ports {
1625                         dAtA[i] = 0xa
1626                         i++
1627                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1628                         n, err := msg.MarshalTo(dAtA[i:])
1629                         if err != nil {
1630                                 return 0, err
1631                         }
1632                         i += n
1633                 }
1634         }
1635         if len(m.From) > 0 {
1636                 for _, msg := range m.From {
1637                         dAtA[i] = 0x12
1638                         i++
1639                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1640                         n, err := msg.MarshalTo(dAtA[i:])
1641                         if err != nil {
1642                                 return 0, err
1643                         }
1644                         i += n
1645                 }
1646         }
1647         return i, nil
1648 }
1649
1650 func (m *NetworkPolicyList) Marshal() (dAtA []byte, err error) {
1651         size := m.Size()
1652         dAtA = make([]byte, size)
1653         n, err := m.MarshalTo(dAtA)
1654         if err != nil {
1655                 return nil, err
1656         }
1657         return dAtA[:n], nil
1658 }
1659
1660 func (m *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) {
1661         var i int
1662         _ = i
1663         var l int
1664         _ = l
1665         dAtA[i] = 0xa
1666         i++
1667         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1668         n34, err := m.ListMeta.MarshalTo(dAtA[i:])
1669         if err != nil {
1670                 return 0, err
1671         }
1672         i += n34
1673         if len(m.Items) > 0 {
1674                 for _, msg := range m.Items {
1675                         dAtA[i] = 0x12
1676                         i++
1677                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1678                         n, err := msg.MarshalTo(dAtA[i:])
1679                         if err != nil {
1680                                 return 0, err
1681                         }
1682                         i += n
1683                 }
1684         }
1685         return i, nil
1686 }
1687
1688 func (m *NetworkPolicyPeer) Marshal() (dAtA []byte, err error) {
1689         size := m.Size()
1690         dAtA = make([]byte, size)
1691         n, err := m.MarshalTo(dAtA)
1692         if err != nil {
1693                 return nil, err
1694         }
1695         return dAtA[:n], nil
1696 }
1697
1698 func (m *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) {
1699         var i int
1700         _ = i
1701         var l int
1702         _ = l
1703         if m.PodSelector != nil {
1704                 dAtA[i] = 0xa
1705                 i++
1706                 i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size()))
1707                 n35, err := m.PodSelector.MarshalTo(dAtA[i:])
1708                 if err != nil {
1709                         return 0, err
1710                 }
1711                 i += n35
1712         }
1713         if m.NamespaceSelector != nil {
1714                 dAtA[i] = 0x12
1715                 i++
1716                 i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
1717                 n36, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
1718                 if err != nil {
1719                         return 0, err
1720                 }
1721                 i += n36
1722         }
1723         if m.IPBlock != nil {
1724                 dAtA[i] = 0x1a
1725                 i++
1726                 i = encodeVarintGenerated(dAtA, i, uint64(m.IPBlock.Size()))
1727                 n37, err := m.IPBlock.MarshalTo(dAtA[i:])
1728                 if err != nil {
1729                         return 0, err
1730                 }
1731                 i += n37
1732         }
1733         return i, nil
1734 }
1735
1736 func (m *NetworkPolicyPort) Marshal() (dAtA []byte, err error) {
1737         size := m.Size()
1738         dAtA = make([]byte, size)
1739         n, err := m.MarshalTo(dAtA)
1740         if err != nil {
1741                 return nil, err
1742         }
1743         return dAtA[:n], nil
1744 }
1745
1746 func (m *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) {
1747         var i int
1748         _ = i
1749         var l int
1750         _ = l
1751         if m.Protocol != nil {
1752                 dAtA[i] = 0xa
1753                 i++
1754                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol)))
1755                 i += copy(dAtA[i:], *m.Protocol)
1756         }
1757         if m.Port != nil {
1758                 dAtA[i] = 0x12
1759                 i++
1760                 i = encodeVarintGenerated(dAtA, i, uint64(m.Port.Size()))
1761                 n38, err := m.Port.MarshalTo(dAtA[i:])
1762                 if err != nil {
1763                         return 0, err
1764                 }
1765                 i += n38
1766         }
1767         return i, nil
1768 }
1769
1770 func (m *NetworkPolicySpec) Marshal() (dAtA []byte, err error) {
1771         size := m.Size()
1772         dAtA = make([]byte, size)
1773         n, err := m.MarshalTo(dAtA)
1774         if err != nil {
1775                 return nil, err
1776         }
1777         return dAtA[:n], nil
1778 }
1779
1780 func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) {
1781         var i int
1782         _ = i
1783         var l int
1784         _ = l
1785         dAtA[i] = 0xa
1786         i++
1787         i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size()))
1788         n39, err := m.PodSelector.MarshalTo(dAtA[i:])
1789         if err != nil {
1790                 return 0, err
1791         }
1792         i += n39
1793         if len(m.Ingress) > 0 {
1794                 for _, msg := range m.Ingress {
1795                         dAtA[i] = 0x12
1796                         i++
1797                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1798                         n, err := msg.MarshalTo(dAtA[i:])
1799                         if err != nil {
1800                                 return 0, err
1801                         }
1802                         i += n
1803                 }
1804         }
1805         if len(m.Egress) > 0 {
1806                 for _, msg := range m.Egress {
1807                         dAtA[i] = 0x1a
1808                         i++
1809                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1810                         n, err := msg.MarshalTo(dAtA[i:])
1811                         if err != nil {
1812                                 return 0, err
1813                         }
1814                         i += n
1815                 }
1816         }
1817         if len(m.PolicyTypes) > 0 {
1818                 for _, s := range m.PolicyTypes {
1819                         dAtA[i] = 0x22
1820                         i++
1821                         l = len(s)
1822                         for l >= 1<<7 {
1823                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1824                                 l >>= 7
1825                                 i++
1826                         }
1827                         dAtA[i] = uint8(l)
1828                         i++
1829                         i += copy(dAtA[i:], s)
1830                 }
1831         }
1832         return i, nil
1833 }
1834
1835 func (m *PodSecurityPolicy) Marshal() (dAtA []byte, err error) {
1836         size := m.Size()
1837         dAtA = make([]byte, size)
1838         n, err := m.MarshalTo(dAtA)
1839         if err != nil {
1840                 return nil, err
1841         }
1842         return dAtA[:n], nil
1843 }
1844
1845 func (m *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) {
1846         var i int
1847         _ = i
1848         var l int
1849         _ = l
1850         dAtA[i] = 0xa
1851         i++
1852         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1853         n40, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1854         if err != nil {
1855                 return 0, err
1856         }
1857         i += n40
1858         dAtA[i] = 0x12
1859         i++
1860         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1861         n41, err := m.Spec.MarshalTo(dAtA[i:])
1862         if err != nil {
1863                 return 0, err
1864         }
1865         i += n41
1866         return i, nil
1867 }
1868
1869 func (m *PodSecurityPolicyList) Marshal() (dAtA []byte, err error) {
1870         size := m.Size()
1871         dAtA = make([]byte, size)
1872         n, err := m.MarshalTo(dAtA)
1873         if err != nil {
1874                 return nil, err
1875         }
1876         return dAtA[:n], nil
1877 }
1878
1879 func (m *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) {
1880         var i int
1881         _ = i
1882         var l int
1883         _ = l
1884         dAtA[i] = 0xa
1885         i++
1886         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1887         n42, err := m.ListMeta.MarshalTo(dAtA[i:])
1888         if err != nil {
1889                 return 0, err
1890         }
1891         i += n42
1892         if len(m.Items) > 0 {
1893                 for _, msg := range m.Items {
1894                         dAtA[i] = 0x12
1895                         i++
1896                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1897                         n, err := msg.MarshalTo(dAtA[i:])
1898                         if err != nil {
1899                                 return 0, err
1900                         }
1901                         i += n
1902                 }
1903         }
1904         return i, nil
1905 }
1906
1907 func (m *PodSecurityPolicySpec) Marshal() (dAtA []byte, err error) {
1908         size := m.Size()
1909         dAtA = make([]byte, size)
1910         n, err := m.MarshalTo(dAtA)
1911         if err != nil {
1912                 return nil, err
1913         }
1914         return dAtA[:n], nil
1915 }
1916
1917 func (m *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) {
1918         var i int
1919         _ = i
1920         var l int
1921         _ = l
1922         dAtA[i] = 0x8
1923         i++
1924         if m.Privileged {
1925                 dAtA[i] = 1
1926         } else {
1927                 dAtA[i] = 0
1928         }
1929         i++
1930         if len(m.DefaultAddCapabilities) > 0 {
1931                 for _, s := range m.DefaultAddCapabilities {
1932                         dAtA[i] = 0x12
1933                         i++
1934                         l = len(s)
1935                         for l >= 1<<7 {
1936                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1937                                 l >>= 7
1938                                 i++
1939                         }
1940                         dAtA[i] = uint8(l)
1941                         i++
1942                         i += copy(dAtA[i:], s)
1943                 }
1944         }
1945         if len(m.RequiredDropCapabilities) > 0 {
1946                 for _, s := range m.RequiredDropCapabilities {
1947                         dAtA[i] = 0x1a
1948                         i++
1949                         l = len(s)
1950                         for l >= 1<<7 {
1951                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1952                                 l >>= 7
1953                                 i++
1954                         }
1955                         dAtA[i] = uint8(l)
1956                         i++
1957                         i += copy(dAtA[i:], s)
1958                 }
1959         }
1960         if len(m.AllowedCapabilities) > 0 {
1961                 for _, s := range m.AllowedCapabilities {
1962                         dAtA[i] = 0x22
1963                         i++
1964                         l = len(s)
1965                         for l >= 1<<7 {
1966                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1967                                 l >>= 7
1968                                 i++
1969                         }
1970                         dAtA[i] = uint8(l)
1971                         i++
1972                         i += copy(dAtA[i:], s)
1973                 }
1974         }
1975         if len(m.Volumes) > 0 {
1976                 for _, s := range m.Volumes {
1977                         dAtA[i] = 0x2a
1978                         i++
1979                         l = len(s)
1980                         for l >= 1<<7 {
1981                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1982                                 l >>= 7
1983                                 i++
1984                         }
1985                         dAtA[i] = uint8(l)
1986                         i++
1987                         i += copy(dAtA[i:], s)
1988                 }
1989         }
1990         dAtA[i] = 0x30
1991         i++
1992         if m.HostNetwork {
1993                 dAtA[i] = 1
1994         } else {
1995                 dAtA[i] = 0
1996         }
1997         i++
1998         if len(m.HostPorts) > 0 {
1999                 for _, msg := range m.HostPorts {
2000                         dAtA[i] = 0x3a
2001                         i++
2002                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2003                         n, err := msg.MarshalTo(dAtA[i:])
2004                         if err != nil {
2005                                 return 0, err
2006                         }
2007                         i += n
2008                 }
2009         }
2010         dAtA[i] = 0x40
2011         i++
2012         if m.HostPID {
2013                 dAtA[i] = 1
2014         } else {
2015                 dAtA[i] = 0
2016         }
2017         i++
2018         dAtA[i] = 0x48
2019         i++
2020         if m.HostIPC {
2021                 dAtA[i] = 1
2022         } else {
2023                 dAtA[i] = 0
2024         }
2025         i++
2026         dAtA[i] = 0x52
2027         i++
2028         i = encodeVarintGenerated(dAtA, i, uint64(m.SELinux.Size()))
2029         n43, err := m.SELinux.MarshalTo(dAtA[i:])
2030         if err != nil {
2031                 return 0, err
2032         }
2033         i += n43
2034         dAtA[i] = 0x5a
2035         i++
2036         i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsUser.Size()))
2037         n44, err := m.RunAsUser.MarshalTo(dAtA[i:])
2038         if err != nil {
2039                 return 0, err
2040         }
2041         i += n44
2042         dAtA[i] = 0x62
2043         i++
2044         i = encodeVarintGenerated(dAtA, i, uint64(m.SupplementalGroups.Size()))
2045         n45, err := m.SupplementalGroups.MarshalTo(dAtA[i:])
2046         if err != nil {
2047                 return 0, err
2048         }
2049         i += n45
2050         dAtA[i] = 0x6a
2051         i++
2052         i = encodeVarintGenerated(dAtA, i, uint64(m.FSGroup.Size()))
2053         n46, err := m.FSGroup.MarshalTo(dAtA[i:])
2054         if err != nil {
2055                 return 0, err
2056         }
2057         i += n46
2058         dAtA[i] = 0x70
2059         i++
2060         if m.ReadOnlyRootFilesystem {
2061                 dAtA[i] = 1
2062         } else {
2063                 dAtA[i] = 0
2064         }
2065         i++
2066         if m.DefaultAllowPrivilegeEscalation != nil {
2067                 dAtA[i] = 0x78
2068                 i++
2069                 if *m.DefaultAllowPrivilegeEscalation {
2070                         dAtA[i] = 1
2071                 } else {
2072                         dAtA[i] = 0
2073                 }
2074                 i++
2075         }
2076         if m.AllowPrivilegeEscalation != nil {
2077                 dAtA[i] = 0x80
2078                 i++
2079                 dAtA[i] = 0x1
2080                 i++
2081                 if *m.AllowPrivilegeEscalation {
2082                         dAtA[i] = 1
2083                 } else {
2084                         dAtA[i] = 0
2085                 }
2086                 i++
2087         }
2088         if len(m.AllowedHostPaths) > 0 {
2089                 for _, msg := range m.AllowedHostPaths {
2090                         dAtA[i] = 0x8a
2091                         i++
2092                         dAtA[i] = 0x1
2093                         i++
2094                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2095                         n, err := msg.MarshalTo(dAtA[i:])
2096                         if err != nil {
2097                                 return 0, err
2098                         }
2099                         i += n
2100                 }
2101         }
2102         if len(m.AllowedFlexVolumes) > 0 {
2103                 for _, msg := range m.AllowedFlexVolumes {
2104                         dAtA[i] = 0x92
2105                         i++
2106                         dAtA[i] = 0x1
2107                         i++
2108                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2109                         n, err := msg.MarshalTo(dAtA[i:])
2110                         if err != nil {
2111                                 return 0, err
2112                         }
2113                         i += n
2114                 }
2115         }
2116         if len(m.AllowedUnsafeSysctls) > 0 {
2117                 for _, s := range m.AllowedUnsafeSysctls {
2118                         dAtA[i] = 0x9a
2119                         i++
2120                         dAtA[i] = 0x1
2121                         i++
2122                         l = len(s)
2123                         for l >= 1<<7 {
2124                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2125                                 l >>= 7
2126                                 i++
2127                         }
2128                         dAtA[i] = uint8(l)
2129                         i++
2130                         i += copy(dAtA[i:], s)
2131                 }
2132         }
2133         if len(m.ForbiddenSysctls) > 0 {
2134                 for _, s := range m.ForbiddenSysctls {
2135                         dAtA[i] = 0xa2
2136                         i++
2137                         dAtA[i] = 0x1
2138                         i++
2139                         l = len(s)
2140                         for l >= 1<<7 {
2141                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2142                                 l >>= 7
2143                                 i++
2144                         }
2145                         dAtA[i] = uint8(l)
2146                         i++
2147                         i += copy(dAtA[i:], s)
2148                 }
2149         }
2150         if len(m.AllowedProcMountTypes) > 0 {
2151                 for _, s := range m.AllowedProcMountTypes {
2152                         dAtA[i] = 0xaa
2153                         i++
2154                         dAtA[i] = 0x1
2155                         i++
2156                         l = len(s)
2157                         for l >= 1<<7 {
2158                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2159                                 l >>= 7
2160                                 i++
2161                         }
2162                         dAtA[i] = uint8(l)
2163                         i++
2164                         i += copy(dAtA[i:], s)
2165                 }
2166         }
2167         if m.RunAsGroup != nil {
2168                 dAtA[i] = 0xb2
2169                 i++
2170                 dAtA[i] = 0x1
2171                 i++
2172                 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsGroup.Size()))
2173                 n47, err := m.RunAsGroup.MarshalTo(dAtA[i:])
2174                 if err != nil {
2175                         return 0, err
2176                 }
2177                 i += n47
2178         }
2179         return i, nil
2180 }
2181
2182 func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
2183         size := m.Size()
2184         dAtA = make([]byte, size)
2185         n, err := m.MarshalTo(dAtA)
2186         if err != nil {
2187                 return nil, err
2188         }
2189         return dAtA[:n], nil
2190 }
2191
2192 func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
2193         var i int
2194         _ = i
2195         var l int
2196         _ = l
2197         dAtA[i] = 0xa
2198         i++
2199         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
2200         n48, err := m.ObjectMeta.MarshalTo(dAtA[i:])
2201         if err != nil {
2202                 return 0, err
2203         }
2204         i += n48
2205         dAtA[i] = 0x12
2206         i++
2207         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2208         n49, err := m.Spec.MarshalTo(dAtA[i:])
2209         if err != nil {
2210                 return 0, err
2211         }
2212         i += n49
2213         dAtA[i] = 0x1a
2214         i++
2215         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
2216         n50, err := m.Status.MarshalTo(dAtA[i:])
2217         if err != nil {
2218                 return 0, err
2219         }
2220         i += n50
2221         return i, nil
2222 }
2223
2224 func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
2225         size := m.Size()
2226         dAtA = make([]byte, size)
2227         n, err := m.MarshalTo(dAtA)
2228         if err != nil {
2229                 return nil, err
2230         }
2231         return dAtA[:n], nil
2232 }
2233
2234 func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
2235         var i int
2236         _ = i
2237         var l int
2238         _ = l
2239         dAtA[i] = 0xa
2240         i++
2241         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2242         i += copy(dAtA[i:], m.Type)
2243         dAtA[i] = 0x12
2244         i++
2245         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
2246         i += copy(dAtA[i:], m.Status)
2247         dAtA[i] = 0x1a
2248         i++
2249         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
2250         n51, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
2251         if err != nil {
2252                 return 0, err
2253         }
2254         i += n51
2255         dAtA[i] = 0x22
2256         i++
2257         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
2258         i += copy(dAtA[i:], m.Reason)
2259         dAtA[i] = 0x2a
2260         i++
2261         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
2262         i += copy(dAtA[i:], m.Message)
2263         return i, nil
2264 }
2265
2266 func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) {
2267         size := m.Size()
2268         dAtA = make([]byte, size)
2269         n, err := m.MarshalTo(dAtA)
2270         if err != nil {
2271                 return nil, err
2272         }
2273         return dAtA[:n], nil
2274 }
2275
2276 func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) {
2277         var i int
2278         _ = i
2279         var l int
2280         _ = l
2281         dAtA[i] = 0xa
2282         i++
2283         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
2284         n52, err := m.ListMeta.MarshalTo(dAtA[i:])
2285         if err != nil {
2286                 return 0, err
2287         }
2288         i += n52
2289         if len(m.Items) > 0 {
2290                 for _, msg := range m.Items {
2291                         dAtA[i] = 0x12
2292                         i++
2293                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2294                         n, err := msg.MarshalTo(dAtA[i:])
2295                         if err != nil {
2296                                 return 0, err
2297                         }
2298                         i += n
2299                 }
2300         }
2301         return i, nil
2302 }
2303
2304 func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
2305         size := m.Size()
2306         dAtA = make([]byte, size)
2307         n, err := m.MarshalTo(dAtA)
2308         if err != nil {
2309                 return nil, err
2310         }
2311         return dAtA[:n], nil
2312 }
2313
2314 func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
2315         var i int
2316         _ = i
2317         var l int
2318         _ = l
2319         if m.Replicas != nil {
2320                 dAtA[i] = 0x8
2321                 i++
2322                 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
2323         }
2324         if m.Selector != nil {
2325                 dAtA[i] = 0x12
2326                 i++
2327                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
2328                 n53, err := m.Selector.MarshalTo(dAtA[i:])
2329                 if err != nil {
2330                         return 0, err
2331                 }
2332                 i += n53
2333         }
2334         dAtA[i] = 0x1a
2335         i++
2336         i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
2337         n54, err := m.Template.MarshalTo(dAtA[i:])
2338         if err != nil {
2339                 return 0, err
2340         }
2341         i += n54
2342         dAtA[i] = 0x20
2343         i++
2344         i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
2345         return i, nil
2346 }
2347
2348 func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
2349         size := m.Size()
2350         dAtA = make([]byte, size)
2351         n, err := m.MarshalTo(dAtA)
2352         if err != nil {
2353                 return nil, err
2354         }
2355         return dAtA[:n], nil
2356 }
2357
2358 func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
2359         var i int
2360         _ = i
2361         var l int
2362         _ = l
2363         dAtA[i] = 0x8
2364         i++
2365         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2366         dAtA[i] = 0x10
2367         i++
2368         i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas))
2369         dAtA[i] = 0x18
2370         i++
2371         i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
2372         dAtA[i] = 0x20
2373         i++
2374         i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
2375         dAtA[i] = 0x28
2376         i++
2377         i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
2378         if len(m.Conditions) > 0 {
2379                 for _, msg := range m.Conditions {
2380                         dAtA[i] = 0x32
2381                         i++
2382                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2383                         n, err := msg.MarshalTo(dAtA[i:])
2384                         if err != nil {
2385                                 return 0, err
2386                         }
2387                         i += n
2388                 }
2389         }
2390         return i, nil
2391 }
2392
2393 func (m *ReplicationControllerDummy) Marshal() (dAtA []byte, err error) {
2394         size := m.Size()
2395         dAtA = make([]byte, size)
2396         n, err := m.MarshalTo(dAtA)
2397         if err != nil {
2398                 return nil, err
2399         }
2400         return dAtA[:n], nil
2401 }
2402
2403 func (m *ReplicationControllerDummy) MarshalTo(dAtA []byte) (int, error) {
2404         var i int
2405         _ = i
2406         var l int
2407         _ = l
2408         return i, nil
2409 }
2410
2411 func (m *RollbackConfig) Marshal() (dAtA []byte, err error) {
2412         size := m.Size()
2413         dAtA = make([]byte, size)
2414         n, err := m.MarshalTo(dAtA)
2415         if err != nil {
2416                 return nil, err
2417         }
2418         return dAtA[:n], nil
2419 }
2420
2421 func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) {
2422         var i int
2423         _ = i
2424         var l int
2425         _ = l
2426         dAtA[i] = 0x8
2427         i++
2428         i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
2429         return i, nil
2430 }
2431
2432 func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) {
2433         size := m.Size()
2434         dAtA = make([]byte, size)
2435         n, err := m.MarshalTo(dAtA)
2436         if err != nil {
2437                 return nil, err
2438         }
2439         return dAtA[:n], nil
2440 }
2441
2442 func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) {
2443         var i int
2444         _ = i
2445         var l int
2446         _ = l
2447         if m.MaxUnavailable != nil {
2448                 dAtA[i] = 0xa
2449                 i++
2450                 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
2451                 n55, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
2452                 if err != nil {
2453                         return 0, err
2454                 }
2455                 i += n55
2456         }
2457         return i, nil
2458 }
2459
2460 func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
2461         size := m.Size()
2462         dAtA = make([]byte, size)
2463         n, err := m.MarshalTo(dAtA)
2464         if err != nil {
2465                 return nil, err
2466         }
2467         return dAtA[:n], nil
2468 }
2469
2470 func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
2471         var i int
2472         _ = i
2473         var l int
2474         _ = l
2475         if m.MaxUnavailable != nil {
2476                 dAtA[i] = 0xa
2477                 i++
2478                 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
2479                 n56, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
2480                 if err != nil {
2481                         return 0, err
2482                 }
2483                 i += n56
2484         }
2485         if m.MaxSurge != nil {
2486                 dAtA[i] = 0x12
2487                 i++
2488                 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size()))
2489                 n57, err := m.MaxSurge.MarshalTo(dAtA[i:])
2490                 if err != nil {
2491                         return 0, err
2492                 }
2493                 i += n57
2494         }
2495         return i, nil
2496 }
2497
2498 func (m *RunAsGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
2499         size := m.Size()
2500         dAtA = make([]byte, size)
2501         n, err := m.MarshalTo(dAtA)
2502         if err != nil {
2503                 return nil, err
2504         }
2505         return dAtA[:n], nil
2506 }
2507
2508 func (m *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2509         var i int
2510         _ = i
2511         var l int
2512         _ = l
2513         dAtA[i] = 0xa
2514         i++
2515         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2516         i += copy(dAtA[i:], m.Rule)
2517         if len(m.Ranges) > 0 {
2518                 for _, msg := range m.Ranges {
2519                         dAtA[i] = 0x12
2520                         i++
2521                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2522                         n, err := msg.MarshalTo(dAtA[i:])
2523                         if err != nil {
2524                                 return 0, err
2525                         }
2526                         i += n
2527                 }
2528         }
2529         return i, nil
2530 }
2531
2532 func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) {
2533         size := m.Size()
2534         dAtA = make([]byte, size)
2535         n, err := m.MarshalTo(dAtA)
2536         if err != nil {
2537                 return nil, err
2538         }
2539         return dAtA[:n], nil
2540 }
2541
2542 func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2543         var i int
2544         _ = i
2545         var l int
2546         _ = l
2547         dAtA[i] = 0xa
2548         i++
2549         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2550         i += copy(dAtA[i:], m.Rule)
2551         if len(m.Ranges) > 0 {
2552                 for _, msg := range m.Ranges {
2553                         dAtA[i] = 0x12
2554                         i++
2555                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2556                         n, err := msg.MarshalTo(dAtA[i:])
2557                         if err != nil {
2558                                 return 0, err
2559                         }
2560                         i += n
2561                 }
2562         }
2563         return i, nil
2564 }
2565
2566 func (m *SELinuxStrategyOptions) Marshal() (dAtA []byte, err error) {
2567         size := m.Size()
2568         dAtA = make([]byte, size)
2569         n, err := m.MarshalTo(dAtA)
2570         if err != nil {
2571                 return nil, err
2572         }
2573         return dAtA[:n], nil
2574 }
2575
2576 func (m *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2577         var i int
2578         _ = i
2579         var l int
2580         _ = l
2581         dAtA[i] = 0xa
2582         i++
2583         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2584         i += copy(dAtA[i:], m.Rule)
2585         if m.SELinuxOptions != nil {
2586                 dAtA[i] = 0x12
2587                 i++
2588                 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinuxOptions.Size()))
2589                 n58, err := m.SELinuxOptions.MarshalTo(dAtA[i:])
2590                 if err != nil {
2591                         return 0, err
2592                 }
2593                 i += n58
2594         }
2595         return i, nil
2596 }
2597
2598 func (m *Scale) Marshal() (dAtA []byte, err error) {
2599         size := m.Size()
2600         dAtA = make([]byte, size)
2601         n, err := m.MarshalTo(dAtA)
2602         if err != nil {
2603                 return nil, err
2604         }
2605         return dAtA[:n], nil
2606 }
2607
2608 func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
2609         var i int
2610         _ = i
2611         var l int
2612         _ = l
2613         dAtA[i] = 0xa
2614         i++
2615         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
2616         n59, err := m.ObjectMeta.MarshalTo(dAtA[i:])
2617         if err != nil {
2618                 return 0, err
2619         }
2620         i += n59
2621         dAtA[i] = 0x12
2622         i++
2623         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2624         n60, err := m.Spec.MarshalTo(dAtA[i:])
2625         if err != nil {
2626                 return 0, err
2627         }
2628         i += n60
2629         dAtA[i] = 0x1a
2630         i++
2631         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
2632         n61, err := m.Status.MarshalTo(dAtA[i:])
2633         if err != nil {
2634                 return 0, err
2635         }
2636         i += n61
2637         return i, nil
2638 }
2639
2640 func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
2641         size := m.Size()
2642         dAtA = make([]byte, size)
2643         n, err := m.MarshalTo(dAtA)
2644         if err != nil {
2645                 return nil, err
2646         }
2647         return dAtA[:n], nil
2648 }
2649
2650 func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
2651         var i int
2652         _ = i
2653         var l int
2654         _ = l
2655         dAtA[i] = 0x8
2656         i++
2657         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2658         return i, nil
2659 }
2660
2661 func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
2662         size := m.Size()
2663         dAtA = make([]byte, size)
2664         n, err := m.MarshalTo(dAtA)
2665         if err != nil {
2666                 return nil, err
2667         }
2668         return dAtA[:n], nil
2669 }
2670
2671 func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
2672         var i int
2673         _ = i
2674         var l int
2675         _ = l
2676         dAtA[i] = 0x8
2677         i++
2678         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2679         if len(m.Selector) > 0 {
2680                 keysForSelector := make([]string, 0, len(m.Selector))
2681                 for k := range m.Selector {
2682                         keysForSelector = append(keysForSelector, string(k))
2683                 }
2684                 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
2685                 for _, k := range keysForSelector {
2686                         dAtA[i] = 0x12
2687                         i++
2688                         v := m.Selector[string(k)]
2689                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2690                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
2691                         dAtA[i] = 0xa
2692                         i++
2693                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
2694                         i += copy(dAtA[i:], k)
2695                         dAtA[i] = 0x12
2696                         i++
2697                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
2698                         i += copy(dAtA[i:], v)
2699                 }
2700         }
2701         dAtA[i] = 0x1a
2702         i++
2703         i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector)))
2704         i += copy(dAtA[i:], m.TargetSelector)
2705         return i, nil
2706 }
2707
2708 func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) {
2709         size := m.Size()
2710         dAtA = make([]byte, size)
2711         n, err := m.MarshalTo(dAtA)
2712         if err != nil {
2713                 return nil, err
2714         }
2715         return dAtA[:n], nil
2716 }
2717
2718 func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2719         var i int
2720         _ = i
2721         var l int
2722         _ = l
2723         dAtA[i] = 0xa
2724         i++
2725         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2726         i += copy(dAtA[i:], m.Rule)
2727         if len(m.Ranges) > 0 {
2728                 for _, msg := range m.Ranges {
2729                         dAtA[i] = 0x12
2730                         i++
2731                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2732                         n, err := msg.MarshalTo(dAtA[i:])
2733                         if err != nil {
2734                                 return 0, err
2735                         }
2736                         i += n
2737                 }
2738         }
2739         return i, nil
2740 }
2741
2742 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
2743         for v >= 1<<7 {
2744                 dAtA[offset] = uint8(v&0x7f | 0x80)
2745                 v >>= 7
2746                 offset++
2747         }
2748         dAtA[offset] = uint8(v)
2749         return offset + 1
2750 }
2751 func (m *AllowedFlexVolume) Size() (n int) {
2752         var l int
2753         _ = l
2754         l = len(m.Driver)
2755         n += 1 + l + sovGenerated(uint64(l))
2756         return n
2757 }
2758
2759 func (m *AllowedHostPath) Size() (n int) {
2760         var l int
2761         _ = l
2762         l = len(m.PathPrefix)
2763         n += 1 + l + sovGenerated(uint64(l))
2764         n += 2
2765         return n
2766 }
2767
2768 func (m *DaemonSet) Size() (n int) {
2769         var l int
2770         _ = l
2771         l = m.ObjectMeta.Size()
2772         n += 1 + l + sovGenerated(uint64(l))
2773         l = m.Spec.Size()
2774         n += 1 + l + sovGenerated(uint64(l))
2775         l = m.Status.Size()
2776         n += 1 + l + sovGenerated(uint64(l))
2777         return n
2778 }
2779
2780 func (m *DaemonSetCondition) Size() (n int) {
2781         var l int
2782         _ = l
2783         l = len(m.Type)
2784         n += 1 + l + sovGenerated(uint64(l))
2785         l = len(m.Status)
2786         n += 1 + l + sovGenerated(uint64(l))
2787         l = m.LastTransitionTime.Size()
2788         n += 1 + l + sovGenerated(uint64(l))
2789         l = len(m.Reason)
2790         n += 1 + l + sovGenerated(uint64(l))
2791         l = len(m.Message)
2792         n += 1 + l + sovGenerated(uint64(l))
2793         return n
2794 }
2795
2796 func (m *DaemonSetList) Size() (n int) {
2797         var l int
2798         _ = l
2799         l = m.ListMeta.Size()
2800         n += 1 + l + sovGenerated(uint64(l))
2801         if len(m.Items) > 0 {
2802                 for _, e := range m.Items {
2803                         l = e.Size()
2804                         n += 1 + l + sovGenerated(uint64(l))
2805                 }
2806         }
2807         return n
2808 }
2809
2810 func (m *DaemonSetSpec) Size() (n int) {
2811         var l int
2812         _ = l
2813         if m.Selector != nil {
2814                 l = m.Selector.Size()
2815                 n += 1 + l + sovGenerated(uint64(l))
2816         }
2817         l = m.Template.Size()
2818         n += 1 + l + sovGenerated(uint64(l))
2819         l = m.UpdateStrategy.Size()
2820         n += 1 + l + sovGenerated(uint64(l))
2821         n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2822         n += 1 + sovGenerated(uint64(m.TemplateGeneration))
2823         if m.RevisionHistoryLimit != nil {
2824                 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2825         }
2826         return n
2827 }
2828
2829 func (m *DaemonSetStatus) Size() (n int) {
2830         var l int
2831         _ = l
2832         n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
2833         n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
2834         n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
2835         n += 1 + sovGenerated(uint64(m.NumberReady))
2836         n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2837         n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled))
2838         n += 1 + sovGenerated(uint64(m.NumberAvailable))
2839         n += 1 + sovGenerated(uint64(m.NumberUnavailable))
2840         if m.CollisionCount != nil {
2841                 n += 1 + sovGenerated(uint64(*m.CollisionCount))
2842         }
2843         if len(m.Conditions) > 0 {
2844                 for _, e := range m.Conditions {
2845                         l = e.Size()
2846                         n += 1 + l + sovGenerated(uint64(l))
2847                 }
2848         }
2849         return n
2850 }
2851
2852 func (m *DaemonSetUpdateStrategy) Size() (n int) {
2853         var l int
2854         _ = l
2855         l = len(m.Type)
2856         n += 1 + l + sovGenerated(uint64(l))
2857         if m.RollingUpdate != nil {
2858                 l = m.RollingUpdate.Size()
2859                 n += 1 + l + sovGenerated(uint64(l))
2860         }
2861         return n
2862 }
2863
2864 func (m *Deployment) Size() (n int) {
2865         var l int
2866         _ = l
2867         l = m.ObjectMeta.Size()
2868         n += 1 + l + sovGenerated(uint64(l))
2869         l = m.Spec.Size()
2870         n += 1 + l + sovGenerated(uint64(l))
2871         l = m.Status.Size()
2872         n += 1 + l + sovGenerated(uint64(l))
2873         return n
2874 }
2875
2876 func (m *DeploymentCondition) Size() (n int) {
2877         var l int
2878         _ = l
2879         l = len(m.Type)
2880         n += 1 + l + sovGenerated(uint64(l))
2881         l = len(m.Status)
2882         n += 1 + l + sovGenerated(uint64(l))
2883         l = len(m.Reason)
2884         n += 1 + l + sovGenerated(uint64(l))
2885         l = len(m.Message)
2886         n += 1 + l + sovGenerated(uint64(l))
2887         l = m.LastUpdateTime.Size()
2888         n += 1 + l + sovGenerated(uint64(l))
2889         l = m.LastTransitionTime.Size()
2890         n += 1 + l + sovGenerated(uint64(l))
2891         return n
2892 }
2893
2894 func (m *DeploymentList) Size() (n int) {
2895         var l int
2896         _ = l
2897         l = m.ListMeta.Size()
2898         n += 1 + l + sovGenerated(uint64(l))
2899         if len(m.Items) > 0 {
2900                 for _, e := range m.Items {
2901                         l = e.Size()
2902                         n += 1 + l + sovGenerated(uint64(l))
2903                 }
2904         }
2905         return n
2906 }
2907
2908 func (m *DeploymentRollback) Size() (n int) {
2909         var l int
2910         _ = l
2911         l = len(m.Name)
2912         n += 1 + l + sovGenerated(uint64(l))
2913         if len(m.UpdatedAnnotations) > 0 {
2914                 for k, v := range m.UpdatedAnnotations {
2915                         _ = k
2916                         _ = v
2917                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2918                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2919                 }
2920         }
2921         l = m.RollbackTo.Size()
2922         n += 1 + l + sovGenerated(uint64(l))
2923         return n
2924 }
2925
2926 func (m *DeploymentSpec) Size() (n int) {
2927         var l int
2928         _ = l
2929         if m.Replicas != nil {
2930                 n += 1 + sovGenerated(uint64(*m.Replicas))
2931         }
2932         if m.Selector != nil {
2933                 l = m.Selector.Size()
2934                 n += 1 + l + sovGenerated(uint64(l))
2935         }
2936         l = m.Template.Size()
2937         n += 1 + l + sovGenerated(uint64(l))
2938         l = m.Strategy.Size()
2939         n += 1 + l + sovGenerated(uint64(l))
2940         n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2941         if m.RevisionHistoryLimit != nil {
2942                 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2943         }
2944         n += 2
2945         if m.RollbackTo != nil {
2946                 l = m.RollbackTo.Size()
2947                 n += 1 + l + sovGenerated(uint64(l))
2948         }
2949         if m.ProgressDeadlineSeconds != nil {
2950                 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
2951         }
2952         return n
2953 }
2954
2955 func (m *DeploymentStatus) Size() (n int) {
2956         var l int
2957         _ = l
2958         n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2959         n += 1 + sovGenerated(uint64(m.Replicas))
2960         n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
2961         n += 1 + sovGenerated(uint64(m.AvailableReplicas))
2962         n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
2963         if len(m.Conditions) > 0 {
2964                 for _, e := range m.Conditions {
2965                         l = e.Size()
2966                         n += 1 + l + sovGenerated(uint64(l))
2967                 }
2968         }
2969         n += 1 + sovGenerated(uint64(m.ReadyReplicas))
2970         if m.CollisionCount != nil {
2971                 n += 1 + sovGenerated(uint64(*m.CollisionCount))
2972         }
2973         return n
2974 }
2975
2976 func (m *DeploymentStrategy) Size() (n int) {
2977         var l int
2978         _ = l
2979         l = len(m.Type)
2980         n += 1 + l + sovGenerated(uint64(l))
2981         if m.RollingUpdate != nil {
2982                 l = m.RollingUpdate.Size()
2983                 n += 1 + l + sovGenerated(uint64(l))
2984         }
2985         return n
2986 }
2987
2988 func (m *FSGroupStrategyOptions) Size() (n int) {
2989         var l int
2990         _ = l
2991         l = len(m.Rule)
2992         n += 1 + l + sovGenerated(uint64(l))
2993         if len(m.Ranges) > 0 {
2994                 for _, e := range m.Ranges {
2995                         l = e.Size()
2996                         n += 1 + l + sovGenerated(uint64(l))
2997                 }
2998         }
2999         return n
3000 }
3001
3002 func (m *HTTPIngressPath) Size() (n int) {
3003         var l int
3004         _ = l
3005         l = len(m.Path)
3006         n += 1 + l + sovGenerated(uint64(l))
3007         l = m.Backend.Size()
3008         n += 1 + l + sovGenerated(uint64(l))
3009         return n
3010 }
3011
3012 func (m *HTTPIngressRuleValue) Size() (n int) {
3013         var l int
3014         _ = l
3015         if len(m.Paths) > 0 {
3016                 for _, e := range m.Paths {
3017                         l = e.Size()
3018                         n += 1 + l + sovGenerated(uint64(l))
3019                 }
3020         }
3021         return n
3022 }
3023
3024 func (m *HostPortRange) Size() (n int) {
3025         var l int
3026         _ = l
3027         n += 1 + sovGenerated(uint64(m.Min))
3028         n += 1 + sovGenerated(uint64(m.Max))
3029         return n
3030 }
3031
3032 func (m *IDRange) Size() (n int) {
3033         var l int
3034         _ = l
3035         n += 1 + sovGenerated(uint64(m.Min))
3036         n += 1 + sovGenerated(uint64(m.Max))
3037         return n
3038 }
3039
3040 func (m *IPBlock) Size() (n int) {
3041         var l int
3042         _ = l
3043         l = len(m.CIDR)
3044         n += 1 + l + sovGenerated(uint64(l))
3045         if len(m.Except) > 0 {
3046                 for _, s := range m.Except {
3047                         l = len(s)
3048                         n += 1 + l + sovGenerated(uint64(l))
3049                 }
3050         }
3051         return n
3052 }
3053
3054 func (m *Ingress) Size() (n int) {
3055         var l int
3056         _ = l
3057         l = m.ObjectMeta.Size()
3058         n += 1 + l + sovGenerated(uint64(l))
3059         l = m.Spec.Size()
3060         n += 1 + l + sovGenerated(uint64(l))
3061         l = m.Status.Size()
3062         n += 1 + l + sovGenerated(uint64(l))
3063         return n
3064 }
3065
3066 func (m *IngressBackend) Size() (n int) {
3067         var l int
3068         _ = l
3069         l = len(m.ServiceName)
3070         n += 1 + l + sovGenerated(uint64(l))
3071         l = m.ServicePort.Size()
3072         n += 1 + l + sovGenerated(uint64(l))
3073         return n
3074 }
3075
3076 func (m *IngressList) Size() (n int) {
3077         var l int
3078         _ = l
3079         l = m.ListMeta.Size()
3080         n += 1 + l + sovGenerated(uint64(l))
3081         if len(m.Items) > 0 {
3082                 for _, e := range m.Items {
3083                         l = e.Size()
3084                         n += 1 + l + sovGenerated(uint64(l))
3085                 }
3086         }
3087         return n
3088 }
3089
3090 func (m *IngressRule) Size() (n int) {
3091         var l int
3092         _ = l
3093         l = len(m.Host)
3094         n += 1 + l + sovGenerated(uint64(l))
3095         l = m.IngressRuleValue.Size()
3096         n += 1 + l + sovGenerated(uint64(l))
3097         return n
3098 }
3099
3100 func (m *IngressRuleValue) Size() (n int) {
3101         var l int
3102         _ = l
3103         if m.HTTP != nil {
3104                 l = m.HTTP.Size()
3105                 n += 1 + l + sovGenerated(uint64(l))
3106         }
3107         return n
3108 }
3109
3110 func (m *IngressSpec) Size() (n int) {
3111         var l int
3112         _ = l
3113         if m.Backend != nil {
3114                 l = m.Backend.Size()
3115                 n += 1 + l + sovGenerated(uint64(l))
3116         }
3117         if len(m.TLS) > 0 {
3118                 for _, e := range m.TLS {
3119                         l = e.Size()
3120                         n += 1 + l + sovGenerated(uint64(l))
3121                 }
3122         }
3123         if len(m.Rules) > 0 {
3124                 for _, e := range m.Rules {
3125                         l = e.Size()
3126                         n += 1 + l + sovGenerated(uint64(l))
3127                 }
3128         }
3129         return n
3130 }
3131
3132 func (m *IngressStatus) Size() (n int) {
3133         var l int
3134         _ = l
3135         l = m.LoadBalancer.Size()
3136         n += 1 + l + sovGenerated(uint64(l))
3137         return n
3138 }
3139
3140 func (m *IngressTLS) Size() (n int) {
3141         var l int
3142         _ = l
3143         if len(m.Hosts) > 0 {
3144                 for _, s := range m.Hosts {
3145                         l = len(s)
3146                         n += 1 + l + sovGenerated(uint64(l))
3147                 }
3148         }
3149         l = len(m.SecretName)
3150         n += 1 + l + sovGenerated(uint64(l))
3151         return n
3152 }
3153
3154 func (m *NetworkPolicy) Size() (n int) {
3155         var l int
3156         _ = l
3157         l = m.ObjectMeta.Size()
3158         n += 1 + l + sovGenerated(uint64(l))
3159         l = m.Spec.Size()
3160         n += 1 + l + sovGenerated(uint64(l))
3161         return n
3162 }
3163
3164 func (m *NetworkPolicyEgressRule) Size() (n int) {
3165         var l int
3166         _ = l
3167         if len(m.Ports) > 0 {
3168                 for _, e := range m.Ports {
3169                         l = e.Size()
3170                         n += 1 + l + sovGenerated(uint64(l))
3171                 }
3172         }
3173         if len(m.To) > 0 {
3174                 for _, e := range m.To {
3175                         l = e.Size()
3176                         n += 1 + l + sovGenerated(uint64(l))
3177                 }
3178         }
3179         return n
3180 }
3181
3182 func (m *NetworkPolicyIngressRule) Size() (n int) {
3183         var l int
3184         _ = l
3185         if len(m.Ports) > 0 {
3186                 for _, e := range m.Ports {
3187                         l = e.Size()
3188                         n += 1 + l + sovGenerated(uint64(l))
3189                 }
3190         }
3191         if len(m.From) > 0 {
3192                 for _, e := range m.From {
3193                         l = e.Size()
3194                         n += 1 + l + sovGenerated(uint64(l))
3195                 }
3196         }
3197         return n
3198 }
3199
3200 func (m *NetworkPolicyList) Size() (n int) {
3201         var l int
3202         _ = l
3203         l = m.ListMeta.Size()
3204         n += 1 + l + sovGenerated(uint64(l))
3205         if len(m.Items) > 0 {
3206                 for _, e := range m.Items {
3207                         l = e.Size()
3208                         n += 1 + l + sovGenerated(uint64(l))
3209                 }
3210         }
3211         return n
3212 }
3213
3214 func (m *NetworkPolicyPeer) Size() (n int) {
3215         var l int
3216         _ = l
3217         if m.PodSelector != nil {
3218                 l = m.PodSelector.Size()
3219                 n += 1 + l + sovGenerated(uint64(l))
3220         }
3221         if m.NamespaceSelector != nil {
3222                 l = m.NamespaceSelector.Size()
3223                 n += 1 + l + sovGenerated(uint64(l))
3224         }
3225         if m.IPBlock != nil {
3226                 l = m.IPBlock.Size()
3227                 n += 1 + l + sovGenerated(uint64(l))
3228         }
3229         return n
3230 }
3231
3232 func (m *NetworkPolicyPort) Size() (n int) {
3233         var l int
3234         _ = l
3235         if m.Protocol != nil {
3236                 l = len(*m.Protocol)
3237                 n += 1 + l + sovGenerated(uint64(l))
3238         }
3239         if m.Port != nil {
3240                 l = m.Port.Size()
3241                 n += 1 + l + sovGenerated(uint64(l))
3242         }
3243         return n
3244 }
3245
3246 func (m *NetworkPolicySpec) Size() (n int) {
3247         var l int
3248         _ = l
3249         l = m.PodSelector.Size()
3250         n += 1 + l + sovGenerated(uint64(l))
3251         if len(m.Ingress) > 0 {
3252                 for _, e := range m.Ingress {
3253                         l = e.Size()
3254                         n += 1 + l + sovGenerated(uint64(l))
3255                 }
3256         }
3257         if len(m.Egress) > 0 {
3258                 for _, e := range m.Egress {
3259                         l = e.Size()
3260                         n += 1 + l + sovGenerated(uint64(l))
3261                 }
3262         }
3263         if len(m.PolicyTypes) > 0 {
3264                 for _, s := range m.PolicyTypes {
3265                         l = len(s)
3266                         n += 1 + l + sovGenerated(uint64(l))
3267                 }
3268         }
3269         return n
3270 }
3271
3272 func (m *PodSecurityPolicy) Size() (n int) {
3273         var l int
3274         _ = l
3275         l = m.ObjectMeta.Size()
3276         n += 1 + l + sovGenerated(uint64(l))
3277         l = m.Spec.Size()
3278         n += 1 + l + sovGenerated(uint64(l))
3279         return n
3280 }
3281
3282 func (m *PodSecurityPolicyList) Size() (n int) {
3283         var l int
3284         _ = l
3285         l = m.ListMeta.Size()
3286         n += 1 + l + sovGenerated(uint64(l))
3287         if len(m.Items) > 0 {
3288                 for _, e := range m.Items {
3289                         l = e.Size()
3290                         n += 1 + l + sovGenerated(uint64(l))
3291                 }
3292         }
3293         return n
3294 }
3295
3296 func (m *PodSecurityPolicySpec) Size() (n int) {
3297         var l int
3298         _ = l
3299         n += 2
3300         if len(m.DefaultAddCapabilities) > 0 {
3301                 for _, s := range m.DefaultAddCapabilities {
3302                         l = len(s)
3303                         n += 1 + l + sovGenerated(uint64(l))
3304                 }
3305         }
3306         if len(m.RequiredDropCapabilities) > 0 {
3307                 for _, s := range m.RequiredDropCapabilities {
3308                         l = len(s)
3309                         n += 1 + l + sovGenerated(uint64(l))
3310                 }
3311         }
3312         if len(m.AllowedCapabilities) > 0 {
3313                 for _, s := range m.AllowedCapabilities {
3314                         l = len(s)
3315                         n += 1 + l + sovGenerated(uint64(l))
3316                 }
3317         }
3318         if len(m.Volumes) > 0 {
3319                 for _, s := range m.Volumes {
3320                         l = len(s)
3321                         n += 1 + l + sovGenerated(uint64(l))
3322                 }
3323         }
3324         n += 2
3325         if len(m.HostPorts) > 0 {
3326                 for _, e := range m.HostPorts {
3327                         l = e.Size()
3328                         n += 1 + l + sovGenerated(uint64(l))
3329                 }
3330         }
3331         n += 2
3332         n += 2
3333         l = m.SELinux.Size()
3334         n += 1 + l + sovGenerated(uint64(l))
3335         l = m.RunAsUser.Size()
3336         n += 1 + l + sovGenerated(uint64(l))
3337         l = m.SupplementalGroups.Size()
3338         n += 1 + l + sovGenerated(uint64(l))
3339         l = m.FSGroup.Size()
3340         n += 1 + l + sovGenerated(uint64(l))
3341         n += 2
3342         if m.DefaultAllowPrivilegeEscalation != nil {
3343                 n += 2
3344         }
3345         if m.AllowPrivilegeEscalation != nil {
3346                 n += 3
3347         }
3348         if len(m.AllowedHostPaths) > 0 {
3349                 for _, e := range m.AllowedHostPaths {
3350                         l = e.Size()
3351                         n += 2 + l + sovGenerated(uint64(l))
3352                 }
3353         }
3354         if len(m.AllowedFlexVolumes) > 0 {
3355                 for _, e := range m.AllowedFlexVolumes {
3356                         l = e.Size()
3357                         n += 2 + l + sovGenerated(uint64(l))
3358                 }
3359         }
3360         if len(m.AllowedUnsafeSysctls) > 0 {
3361                 for _, s := range m.AllowedUnsafeSysctls {
3362                         l = len(s)
3363                         n += 2 + l + sovGenerated(uint64(l))
3364                 }
3365         }
3366         if len(m.ForbiddenSysctls) > 0 {
3367                 for _, s := range m.ForbiddenSysctls {
3368                         l = len(s)
3369                         n += 2 + l + sovGenerated(uint64(l))
3370                 }
3371         }
3372         if len(m.AllowedProcMountTypes) > 0 {
3373                 for _, s := range m.AllowedProcMountTypes {
3374                         l = len(s)
3375                         n += 2 + l + sovGenerated(uint64(l))
3376                 }
3377         }
3378         if m.RunAsGroup != nil {
3379                 l = m.RunAsGroup.Size()
3380                 n += 2 + l + sovGenerated(uint64(l))
3381         }
3382         return n
3383 }
3384
3385 func (m *ReplicaSet) Size() (n int) {
3386         var l int
3387         _ = l
3388         l = m.ObjectMeta.Size()
3389         n += 1 + l + sovGenerated(uint64(l))
3390         l = m.Spec.Size()
3391         n += 1 + l + sovGenerated(uint64(l))
3392         l = m.Status.Size()
3393         n += 1 + l + sovGenerated(uint64(l))
3394         return n
3395 }
3396
3397 func (m *ReplicaSetCondition) Size() (n int) {
3398         var l int
3399         _ = l
3400         l = len(m.Type)
3401         n += 1 + l + sovGenerated(uint64(l))
3402         l = len(m.Status)
3403         n += 1 + l + sovGenerated(uint64(l))
3404         l = m.LastTransitionTime.Size()
3405         n += 1 + l + sovGenerated(uint64(l))
3406         l = len(m.Reason)
3407         n += 1 + l + sovGenerated(uint64(l))
3408         l = len(m.Message)
3409         n += 1 + l + sovGenerated(uint64(l))
3410         return n
3411 }
3412
3413 func (m *ReplicaSetList) Size() (n int) {
3414         var l int
3415         _ = l
3416         l = m.ListMeta.Size()
3417         n += 1 + l + sovGenerated(uint64(l))
3418         if len(m.Items) > 0 {
3419                 for _, e := range m.Items {
3420                         l = e.Size()
3421                         n += 1 + l + sovGenerated(uint64(l))
3422                 }
3423         }
3424         return n
3425 }
3426
3427 func (m *ReplicaSetSpec) Size() (n int) {
3428         var l int
3429         _ = l
3430         if m.Replicas != nil {
3431                 n += 1 + sovGenerated(uint64(*m.Replicas))
3432         }
3433         if m.Selector != nil {
3434                 l = m.Selector.Size()
3435                 n += 1 + l + sovGenerated(uint64(l))
3436         }
3437         l = m.Template.Size()
3438         n += 1 + l + sovGenerated(uint64(l))
3439         n += 1 + sovGenerated(uint64(m.MinReadySeconds))
3440         return n
3441 }
3442
3443 func (m *ReplicaSetStatus) Size() (n int) {
3444         var l int
3445         _ = l
3446         n += 1 + sovGenerated(uint64(m.Replicas))
3447         n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
3448         n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3449         n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3450         n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3451         if len(m.Conditions) > 0 {
3452                 for _, e := range m.Conditions {
3453                         l = e.Size()
3454                         n += 1 + l + sovGenerated(uint64(l))
3455                 }
3456         }
3457         return n
3458 }
3459
3460 func (m *ReplicationControllerDummy) Size() (n int) {
3461         var l int
3462         _ = l
3463         return n
3464 }
3465
3466 func (m *RollbackConfig) Size() (n int) {
3467         var l int
3468         _ = l
3469         n += 1 + sovGenerated(uint64(m.Revision))
3470         return n
3471 }
3472
3473 func (m *RollingUpdateDaemonSet) Size() (n int) {
3474         var l int
3475         _ = l
3476         if m.MaxUnavailable != nil {
3477                 l = m.MaxUnavailable.Size()
3478                 n += 1 + l + sovGenerated(uint64(l))
3479         }
3480         return n
3481 }
3482
3483 func (m *RollingUpdateDeployment) Size() (n int) {
3484         var l int
3485         _ = l
3486         if m.MaxUnavailable != nil {
3487                 l = m.MaxUnavailable.Size()
3488                 n += 1 + l + sovGenerated(uint64(l))
3489         }
3490         if m.MaxSurge != nil {
3491                 l = m.MaxSurge.Size()
3492                 n += 1 + l + sovGenerated(uint64(l))
3493         }
3494         return n
3495 }
3496
3497 func (m *RunAsGroupStrategyOptions) Size() (n int) {
3498         var l int
3499         _ = l
3500         l = len(m.Rule)
3501         n += 1 + l + sovGenerated(uint64(l))
3502         if len(m.Ranges) > 0 {
3503                 for _, e := range m.Ranges {
3504                         l = e.Size()
3505                         n += 1 + l + sovGenerated(uint64(l))
3506                 }
3507         }
3508         return n
3509 }
3510
3511 func (m *RunAsUserStrategyOptions) Size() (n int) {
3512         var l int
3513         _ = l
3514         l = len(m.Rule)
3515         n += 1 + l + sovGenerated(uint64(l))
3516         if len(m.Ranges) > 0 {
3517                 for _, e := range m.Ranges {
3518                         l = e.Size()
3519                         n += 1 + l + sovGenerated(uint64(l))
3520                 }
3521         }
3522         return n
3523 }
3524
3525 func (m *SELinuxStrategyOptions) Size() (n int) {
3526         var l int
3527         _ = l
3528         l = len(m.Rule)
3529         n += 1 + l + sovGenerated(uint64(l))
3530         if m.SELinuxOptions != nil {
3531                 l = m.SELinuxOptions.Size()
3532                 n += 1 + l + sovGenerated(uint64(l))
3533         }
3534         return n
3535 }
3536
3537 func (m *Scale) Size() (n int) {
3538         var l int
3539         _ = l
3540         l = m.ObjectMeta.Size()
3541         n += 1 + l + sovGenerated(uint64(l))
3542         l = m.Spec.Size()
3543         n += 1 + l + sovGenerated(uint64(l))
3544         l = m.Status.Size()
3545         n += 1 + l + sovGenerated(uint64(l))
3546         return n
3547 }
3548
3549 func (m *ScaleSpec) Size() (n int) {
3550         var l int
3551         _ = l
3552         n += 1 + sovGenerated(uint64(m.Replicas))
3553         return n
3554 }
3555
3556 func (m *ScaleStatus) Size() (n int) {
3557         var l int
3558         _ = l
3559         n += 1 + sovGenerated(uint64(m.Replicas))
3560         if len(m.Selector) > 0 {
3561                 for k, v := range m.Selector {
3562                         _ = k
3563                         _ = v
3564                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
3565                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
3566                 }
3567         }
3568         l = len(m.TargetSelector)
3569         n += 1 + l + sovGenerated(uint64(l))
3570         return n
3571 }
3572
3573 func (m *SupplementalGroupsStrategyOptions) Size() (n int) {
3574         var l int
3575         _ = l
3576         l = len(m.Rule)
3577         n += 1 + l + sovGenerated(uint64(l))
3578         if len(m.Ranges) > 0 {
3579                 for _, e := range m.Ranges {
3580                         l = e.Size()
3581                         n += 1 + l + sovGenerated(uint64(l))
3582                 }
3583         }
3584         return n
3585 }
3586
3587 func sovGenerated(x uint64) (n int) {
3588         for {
3589                 n++
3590                 x >>= 7
3591                 if x == 0 {
3592                         break
3593                 }
3594         }
3595         return n
3596 }
3597 func sozGenerated(x uint64) (n int) {
3598         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3599 }
3600 func (this *AllowedFlexVolume) String() string {
3601         if this == nil {
3602                 return "nil"
3603         }
3604         s := strings.Join([]string{`&AllowedFlexVolume{`,
3605                 `Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
3606                 `}`,
3607         }, "")
3608         return s
3609 }
3610 func (this *AllowedHostPath) String() string {
3611         if this == nil {
3612                 return "nil"
3613         }
3614         s := strings.Join([]string{`&AllowedHostPath{`,
3615                 `PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`,
3616                 `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
3617                 `}`,
3618         }, "")
3619         return s
3620 }
3621 func (this *DaemonSet) String() string {
3622         if this == nil {
3623                 return "nil"
3624         }
3625         s := strings.Join([]string{`&DaemonSet{`,
3626                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3627                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`,
3628                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`,
3629                 `}`,
3630         }, "")
3631         return s
3632 }
3633 func (this *DaemonSetCondition) String() string {
3634         if this == nil {
3635                 return "nil"
3636         }
3637         s := strings.Join([]string{`&DaemonSetCondition{`,
3638                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3639                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3640                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3641                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3642                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3643                 `}`,
3644         }, "")
3645         return s
3646 }
3647 func (this *DaemonSetList) String() string {
3648         if this == nil {
3649                 return "nil"
3650         }
3651         s := strings.Join([]string{`&DaemonSetList{`,
3652                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3653                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + `,`,
3654                 `}`,
3655         }, "")
3656         return s
3657 }
3658 func (this *DaemonSetSpec) String() string {
3659         if this == nil {
3660                 return "nil"
3661         }
3662         s := strings.Join([]string{`&DaemonSetSpec{`,
3663                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
3664                 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3665                 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
3666                 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3667                 `TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`,
3668                 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3669                 `}`,
3670         }, "")
3671         return s
3672 }
3673 func (this *DaemonSetStatus) String() string {
3674         if this == nil {
3675                 return "nil"
3676         }
3677         s := strings.Join([]string{`&DaemonSetStatus{`,
3678                 `CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`,
3679                 `NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`,
3680                 `DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`,
3681                 `NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`,
3682                 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3683                 `UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`,
3684                 `NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`,
3685                 `NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`,
3686                 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3687                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + `,`,
3688                 `}`,
3689         }, "")
3690         return s
3691 }
3692 func (this *DaemonSetUpdateStrategy) String() string {
3693         if this == nil {
3694                 return "nil"
3695         }
3696         s := strings.Join([]string{`&DaemonSetUpdateStrategy{`,
3697                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3698                 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`,
3699                 `}`,
3700         }, "")
3701         return s
3702 }
3703 func (this *Deployment) String() string {
3704         if this == nil {
3705                 return "nil"
3706         }
3707         s := strings.Join([]string{`&Deployment{`,
3708                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3709                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
3710                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
3711                 `}`,
3712         }, "")
3713         return s
3714 }
3715 func (this *DeploymentCondition) String() string {
3716         if this == nil {
3717                 return "nil"
3718         }
3719         s := strings.Join([]string{`&DeploymentCondition{`,
3720                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3721                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3722                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3723                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3724                 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3725                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3726                 `}`,
3727         }, "")
3728         return s
3729 }
3730 func (this *DeploymentList) String() string {
3731         if this == nil {
3732                 return "nil"
3733         }
3734         s := strings.Join([]string{`&DeploymentList{`,
3735                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3736                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`,
3737                 `}`,
3738         }, "")
3739         return s
3740 }
3741 func (this *DeploymentRollback) String() string {
3742         if this == nil {
3743                 return "nil"
3744         }
3745         keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations))
3746         for k := range this.UpdatedAnnotations {
3747                 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k)
3748         }
3749         github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
3750         mapStringForUpdatedAnnotations := "map[string]string{"
3751         for _, k := range keysForUpdatedAnnotations {
3752                 mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k])
3753         }
3754         mapStringForUpdatedAnnotations += "}"
3755         s := strings.Join([]string{`&DeploymentRollback{`,
3756                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3757                 `UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`,
3758                 `RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`,
3759                 `}`,
3760         }, "")
3761         return s
3762 }
3763 func (this *DeploymentSpec) String() string {
3764         if this == nil {
3765                 return "nil"
3766         }
3767         s := strings.Join([]string{`&DeploymentSpec{`,
3768                 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
3769                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
3770                 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3771                 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
3772                 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3773                 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3774                 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
3775                 `RollbackTo:` + strings.Replace(fmt.Sprintf("%v", this.RollbackTo), "RollbackConfig", "RollbackConfig", 1) + `,`,
3776                 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
3777                 `}`,
3778         }, "")
3779         return s
3780 }
3781 func (this *DeploymentStatus) String() string {
3782         if this == nil {
3783                 return "nil"
3784         }
3785         s := strings.Join([]string{`&DeploymentStatus{`,
3786                 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3787                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
3788                 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
3789                 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
3790                 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
3791                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`,
3792                 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
3793                 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3794                 `}`,
3795         }, "")
3796         return s
3797 }
3798 func (this *DeploymentStrategy) String() string {
3799         if this == nil {
3800                 return "nil"
3801         }
3802         s := strings.Join([]string{`&DeploymentStrategy{`,
3803                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3804                 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
3805                 `}`,
3806         }, "")
3807         return s
3808 }
3809 func (this *FSGroupStrategyOptions) String() string {
3810         if this == nil {
3811                 return "nil"
3812         }
3813         s := strings.Join([]string{`&FSGroupStrategyOptions{`,
3814                 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
3815                 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
3816                 `}`,
3817         }, "")
3818         return s
3819 }
3820 func (this *HTTPIngressPath) String() string {
3821         if this == nil {
3822                 return "nil"
3823         }
3824         s := strings.Join([]string{`&HTTPIngressPath{`,
3825                 `Path:` + fmt.Sprintf("%v", this.Path) + `,`,
3826                 `Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`,
3827                 `}`,
3828         }, "")
3829         return s
3830 }
3831 func (this *HTTPIngressRuleValue) String() string {
3832         if this == nil {
3833                 return "nil"
3834         }
3835         s := strings.Join([]string{`&HTTPIngressRuleValue{`,
3836                 `Paths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Paths), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + `,`,
3837                 `}`,
3838         }, "")
3839         return s
3840 }
3841 func (this *HostPortRange) String() string {
3842         if this == nil {
3843                 return "nil"
3844         }
3845         s := strings.Join([]string{`&HostPortRange{`,
3846                 `Min:` + fmt.Sprintf("%v", this.Min) + `,`,
3847                 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
3848                 `}`,
3849         }, "")
3850         return s
3851 }
3852 func (this *IDRange) String() string {
3853         if this == nil {
3854                 return "nil"
3855         }
3856         s := strings.Join([]string{`&IDRange{`,
3857                 `Min:` + fmt.Sprintf("%v", this.Min) + `,`,
3858                 `Max:` + fmt.Sprintf("%v", this.Max) + `,`,
3859                 `}`,
3860         }, "")
3861         return s
3862 }
3863 func (this *IPBlock) String() string {
3864         if this == nil {
3865                 return "nil"
3866         }
3867         s := strings.Join([]string{`&IPBlock{`,
3868                 `CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`,
3869                 `Except:` + fmt.Sprintf("%v", this.Except) + `,`,
3870                 `}`,
3871         }, "")
3872         return s
3873 }
3874 func (this *Ingress) String() string {
3875         if this == nil {
3876                 return "nil"
3877         }
3878         s := strings.Join([]string{`&Ingress{`,
3879                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3880                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`,
3881                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`,
3882                 `}`,
3883         }, "")
3884         return s
3885 }
3886 func (this *IngressBackend) String() string {
3887         if this == nil {
3888                 return "nil"
3889         }
3890         s := strings.Join([]string{`&IngressBackend{`,
3891                 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
3892                 `ServicePort:` + strings.Replace(strings.Replace(this.ServicePort.String(), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1), `&`, ``, 1) + `,`,
3893                 `}`,
3894         }, "")
3895         return s
3896 }
3897 func (this *IngressList) String() string {
3898         if this == nil {
3899                 return "nil"
3900         }
3901         s := strings.Join([]string{`&IngressList{`,
3902                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3903                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Ingress", "Ingress", 1), `&`, ``, 1) + `,`,
3904                 `}`,
3905         }, "")
3906         return s
3907 }
3908 func (this *IngressRule) String() string {
3909         if this == nil {
3910                 return "nil"
3911         }
3912         s := strings.Join([]string{`&IngressRule{`,
3913                 `Host:` + fmt.Sprintf("%v", this.Host) + `,`,
3914                 `IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`,
3915                 `}`,
3916         }, "")
3917         return s
3918 }
3919 func (this *IngressRuleValue) String() string {
3920         if this == nil {
3921                 return "nil"
3922         }
3923         s := strings.Join([]string{`&IngressRuleValue{`,
3924                 `HTTP:` + strings.Replace(fmt.Sprintf("%v", this.HTTP), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`,
3925                 `}`,
3926         }, "")
3927         return s
3928 }
3929 func (this *IngressSpec) String() string {
3930         if this == nil {
3931                 return "nil"
3932         }
3933         s := strings.Join([]string{`&IngressSpec{`,
3934                 `Backend:` + strings.Replace(fmt.Sprintf("%v", this.Backend), "IngressBackend", "IngressBackend", 1) + `,`,
3935                 `TLS:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TLS), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + `,`,
3936                 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "IngressRule", "IngressRule", 1), `&`, ``, 1) + `,`,
3937                 `}`,
3938         }, "")
3939         return s
3940 }
3941 func (this *IngressStatus) String() string {
3942         if this == nil {
3943                 return "nil"
3944         }
3945         s := strings.Join([]string{`&IngressStatus{`,
3946                 `LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "LoadBalancerStatus", "k8s_io_api_core_v1.LoadBalancerStatus", 1), `&`, ``, 1) + `,`,
3947                 `}`,
3948         }, "")
3949         return s
3950 }
3951 func (this *IngressTLS) String() string {
3952         if this == nil {
3953                 return "nil"
3954         }
3955         s := strings.Join([]string{`&IngressTLS{`,
3956                 `Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`,
3957                 `SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`,
3958                 `}`,
3959         }, "")
3960         return s
3961 }
3962 func (this *NetworkPolicy) String() string {
3963         if this == nil {
3964                 return "nil"
3965         }
3966         s := strings.Join([]string{`&NetworkPolicy{`,
3967                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3968                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`,
3969                 `}`,
3970         }, "")
3971         return s
3972 }
3973 func (this *NetworkPolicyEgressRule) String() string {
3974         if this == nil {
3975                 return "nil"
3976         }
3977         s := strings.Join([]string{`&NetworkPolicyEgressRule{`,
3978                 `Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`,
3979                 `To:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.To), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`,
3980                 `}`,
3981         }, "")
3982         return s
3983 }
3984 func (this *NetworkPolicyIngressRule) String() string {
3985         if this == nil {
3986                 return "nil"
3987         }
3988         s := strings.Join([]string{`&NetworkPolicyIngressRule{`,
3989                 `Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`,
3990                 `From:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.From), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`,
3991                 `}`,
3992         }, "")
3993         return s
3994 }
3995 func (this *NetworkPolicyList) String() string {
3996         if this == nil {
3997                 return "nil"
3998         }
3999         s := strings.Join([]string{`&NetworkPolicyList{`,
4000                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4001                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + `,`,
4002                 `}`,
4003         }, "")
4004         return s
4005 }
4006 func (this *NetworkPolicyPeer) String() string {
4007         if this == nil {
4008                 return "nil"
4009         }
4010         s := strings.Join([]string{`&NetworkPolicyPeer{`,
4011                 `PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4012                 `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4013                 `IPBlock:` + strings.Replace(fmt.Sprintf("%v", this.IPBlock), "IPBlock", "IPBlock", 1) + `,`,
4014                 `}`,
4015         }, "")
4016         return s
4017 }
4018 func (this *NetworkPolicyPort) String() string {
4019         if this == nil {
4020                 return "nil"
4021         }
4022         s := strings.Join([]string{`&NetworkPolicyPort{`,
4023                 `Protocol:` + valueToStringGenerated(this.Protocol) + `,`,
4024                 `Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4025                 `}`,
4026         }, "")
4027         return s
4028 }
4029 func (this *NetworkPolicySpec) String() string {
4030         if this == nil {
4031                 return "nil"
4032         }
4033         s := strings.Join([]string{`&NetworkPolicySpec{`,
4034                 `PodSelector:` + strings.Replace(strings.Replace(this.PodSelector.String(), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`,
4035                 `Ingress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ingress), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + `,`,
4036                 `Egress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Egress), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + `,`,
4037                 `PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`,
4038                 `}`,
4039         }, "")
4040         return s
4041 }
4042 func (this *PodSecurityPolicy) String() string {
4043         if this == nil {
4044                 return "nil"
4045         }
4046         s := strings.Join([]string{`&PodSecurityPolicy{`,
4047                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4048                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`,
4049                 `}`,
4050         }, "")
4051         return s
4052 }
4053 func (this *PodSecurityPolicyList) String() string {
4054         if this == nil {
4055                 return "nil"
4056         }
4057         s := strings.Join([]string{`&PodSecurityPolicyList{`,
4058                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4059                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + `,`,
4060                 `}`,
4061         }, "")
4062         return s
4063 }
4064 func (this *PodSecurityPolicySpec) String() string {
4065         if this == nil {
4066                 return "nil"
4067         }
4068         s := strings.Join([]string{`&PodSecurityPolicySpec{`,
4069                 `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
4070                 `DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`,
4071                 `RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`,
4072                 `AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`,
4073                 `Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`,
4074                 `HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`,
4075                 `HostPorts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.HostPorts), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + `,`,
4076                 `HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`,
4077                 `HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`,
4078                 `SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`,
4079                 `RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`,
4080                 `SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`,
4081                 `FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`,
4082                 `ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`,
4083                 `DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`,
4084                 `AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`,
4085                 `AllowedHostPaths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedHostPaths), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + `,`,
4086                 `AllowedFlexVolumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedFlexVolumes), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + `,`,
4087                 `AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`,
4088                 `ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`,
4089                 `AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`,
4090                 `RunAsGroup:` + strings.Replace(fmt.Sprintf("%v", this.RunAsGroup), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`,
4091                 `}`,
4092         }, "")
4093         return s
4094 }
4095 func (this *ReplicaSet) String() string {
4096         if this == nil {
4097                 return "nil"
4098         }
4099         s := strings.Join([]string{`&ReplicaSet{`,
4100                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4101                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
4102                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
4103                 `}`,
4104         }, "")
4105         return s
4106 }
4107 func (this *ReplicaSetCondition) String() string {
4108         if this == nil {
4109                 return "nil"
4110         }
4111         s := strings.Join([]string{`&ReplicaSetCondition{`,
4112                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4113                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
4114                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
4115                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
4116                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
4117                 `}`,
4118         }, "")
4119         return s
4120 }
4121 func (this *ReplicaSetList) String() string {
4122         if this == nil {
4123                 return "nil"
4124         }
4125         s := strings.Join([]string{`&ReplicaSetList{`,
4126                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4127                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + `,`,
4128                 `}`,
4129         }, "")
4130         return s
4131 }
4132 func (this *ReplicaSetSpec) String() string {
4133         if this == nil {
4134                 return "nil"
4135         }
4136         s := strings.Join([]string{`&ReplicaSetSpec{`,
4137                 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
4138                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4139                 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
4140                 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
4141                 `}`,
4142         }, "")
4143         return s
4144 }
4145 func (this *ReplicaSetStatus) String() string {
4146         if this == nil {
4147                 return "nil"
4148         }
4149         s := strings.Join([]string{`&ReplicaSetStatus{`,
4150                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4151                 `FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
4152                 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
4153                 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
4154                 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
4155                 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + `,`,
4156                 `}`,
4157         }, "")
4158         return s
4159 }
4160 func (this *ReplicationControllerDummy) String() string {
4161         if this == nil {
4162                 return "nil"
4163         }
4164         s := strings.Join([]string{`&ReplicationControllerDummy{`,
4165                 `}`,
4166         }, "")
4167         return s
4168 }
4169 func (this *RollbackConfig) String() string {
4170         if this == nil {
4171                 return "nil"
4172         }
4173         s := strings.Join([]string{`&RollbackConfig{`,
4174                 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
4175                 `}`,
4176         }, "")
4177         return s
4178 }
4179 func (this *RollingUpdateDaemonSet) String() string {
4180         if this == nil {
4181                 return "nil"
4182         }
4183         s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
4184                 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4185                 `}`,
4186         }, "")
4187         return s
4188 }
4189 func (this *RollingUpdateDeployment) String() string {
4190         if this == nil {
4191                 return "nil"
4192         }
4193         s := strings.Join([]string{`&RollingUpdateDeployment{`,
4194                 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4195                 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4196                 `}`,
4197         }, "")
4198         return s
4199 }
4200 func (this *RunAsGroupStrategyOptions) String() string {
4201         if this == nil {
4202                 return "nil"
4203         }
4204         s := strings.Join([]string{`&RunAsGroupStrategyOptions{`,
4205                 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4206                 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4207                 `}`,
4208         }, "")
4209         return s
4210 }
4211 func (this *RunAsUserStrategyOptions) String() string {
4212         if this == nil {
4213                 return "nil"
4214         }
4215         s := strings.Join([]string{`&RunAsUserStrategyOptions{`,
4216                 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4217                 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4218                 `}`,
4219         }, "")
4220         return s
4221 }
4222 func (this *SELinuxStrategyOptions) String() string {
4223         if this == nil {
4224                 return "nil"
4225         }
4226         s := strings.Join([]string{`&SELinuxStrategyOptions{`,
4227                 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4228                 `SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "k8s_io_api_core_v1.SELinuxOptions", 1) + `,`,
4229                 `}`,
4230         }, "")
4231         return s
4232 }
4233 func (this *Scale) String() string {
4234         if this == nil {
4235                 return "nil"
4236         }
4237         s := strings.Join([]string{`&Scale{`,
4238                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4239                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
4240                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
4241                 `}`,
4242         }, "")
4243         return s
4244 }
4245 func (this *ScaleSpec) String() string {
4246         if this == nil {
4247                 return "nil"
4248         }
4249         s := strings.Join([]string{`&ScaleSpec{`,
4250                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4251                 `}`,
4252         }, "")
4253         return s
4254 }
4255 func (this *ScaleStatus) String() string {
4256         if this == nil {
4257                 return "nil"
4258         }
4259         keysForSelector := make([]string, 0, len(this.Selector))
4260         for k := range this.Selector {
4261                 keysForSelector = append(keysForSelector, k)
4262         }
4263         github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
4264         mapStringForSelector := "map[string]string{"
4265         for _, k := range keysForSelector {
4266                 mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k])
4267         }
4268         mapStringForSelector += "}"
4269         s := strings.Join([]string{`&ScaleStatus{`,
4270                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4271                 `Selector:` + mapStringForSelector + `,`,
4272                 `TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`,
4273                 `}`,
4274         }, "")
4275         return s
4276 }
4277 func (this *SupplementalGroupsStrategyOptions) String() string {
4278         if this == nil {
4279                 return "nil"
4280         }
4281         s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`,
4282                 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4283                 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4284                 `}`,
4285         }, "")
4286         return s
4287 }
4288 func valueToStringGenerated(v interface{}) string {
4289         rv := reflect.ValueOf(v)
4290         if rv.IsNil() {
4291                 return "nil"
4292         }
4293         pv := reflect.Indirect(rv).Interface()
4294         return fmt.Sprintf("*%v", pv)
4295 }
4296 func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error {
4297         l := len(dAtA)
4298         iNdEx := 0
4299         for iNdEx < l {
4300                 preIndex := iNdEx
4301                 var wire uint64
4302                 for shift := uint(0); ; shift += 7 {
4303                         if shift >= 64 {
4304                                 return ErrIntOverflowGenerated
4305                         }
4306                         if iNdEx >= l {
4307                                 return io.ErrUnexpectedEOF
4308                         }
4309                         b := dAtA[iNdEx]
4310                         iNdEx++
4311                         wire |= (uint64(b) & 0x7F) << shift
4312                         if b < 0x80 {
4313                                 break
4314                         }
4315                 }
4316                 fieldNum := int32(wire >> 3)
4317                 wireType := int(wire & 0x7)
4318                 if wireType == 4 {
4319                         return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group")
4320                 }
4321                 if fieldNum <= 0 {
4322                         return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire)
4323                 }
4324                 switch fieldNum {
4325                 case 1:
4326                         if wireType != 2 {
4327                                 return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
4328                         }
4329                         var stringLen uint64
4330                         for shift := uint(0); ; shift += 7 {
4331                                 if shift >= 64 {
4332                                         return ErrIntOverflowGenerated
4333                                 }
4334                                 if iNdEx >= l {
4335                                         return io.ErrUnexpectedEOF
4336                                 }
4337                                 b := dAtA[iNdEx]
4338                                 iNdEx++
4339                                 stringLen |= (uint64(b) & 0x7F) << shift
4340                                 if b < 0x80 {
4341                                         break
4342                                 }
4343                         }
4344                         intStringLen := int(stringLen)
4345                         if intStringLen < 0 {
4346                                 return ErrInvalidLengthGenerated
4347                         }
4348                         postIndex := iNdEx + intStringLen
4349                         if postIndex > l {
4350                                 return io.ErrUnexpectedEOF
4351                         }
4352                         m.Driver = string(dAtA[iNdEx:postIndex])
4353                         iNdEx = postIndex
4354                 default:
4355                         iNdEx = preIndex
4356                         skippy, err := skipGenerated(dAtA[iNdEx:])
4357                         if err != nil {
4358                                 return err
4359                         }
4360                         if skippy < 0 {
4361                                 return ErrInvalidLengthGenerated
4362                         }
4363                         if (iNdEx + skippy) > l {
4364                                 return io.ErrUnexpectedEOF
4365                         }
4366                         iNdEx += skippy
4367                 }
4368         }
4369
4370         if iNdEx > l {
4371                 return io.ErrUnexpectedEOF
4372         }
4373         return nil
4374 }
4375 func (m *AllowedHostPath) Unmarshal(dAtA []byte) error {
4376         l := len(dAtA)
4377         iNdEx := 0
4378         for iNdEx < l {
4379                 preIndex := iNdEx
4380                 var wire uint64
4381                 for shift := uint(0); ; shift += 7 {
4382                         if shift >= 64 {
4383                                 return ErrIntOverflowGenerated
4384                         }
4385                         if iNdEx >= l {
4386                                 return io.ErrUnexpectedEOF
4387                         }
4388                         b := dAtA[iNdEx]
4389                         iNdEx++
4390                         wire |= (uint64(b) & 0x7F) << shift
4391                         if b < 0x80 {
4392                                 break
4393                         }
4394                 }
4395                 fieldNum := int32(wire >> 3)
4396                 wireType := int(wire & 0x7)
4397                 if wireType == 4 {
4398                         return fmt.Errorf("proto: AllowedHostPath: wiretype end group for non-group")
4399                 }
4400                 if fieldNum <= 0 {
4401                         return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire)
4402                 }
4403                 switch fieldNum {
4404                 case 1:
4405                         if wireType != 2 {
4406                                 return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType)
4407                         }
4408                         var stringLen uint64
4409                         for shift := uint(0); ; shift += 7 {
4410                                 if shift >= 64 {
4411                                         return ErrIntOverflowGenerated
4412                                 }
4413                                 if iNdEx >= l {
4414                                         return io.ErrUnexpectedEOF
4415                                 }
4416                                 b := dAtA[iNdEx]
4417                                 iNdEx++
4418                                 stringLen |= (uint64(b) & 0x7F) << shift
4419                                 if b < 0x80 {
4420                                         break
4421                                 }
4422                         }
4423                         intStringLen := int(stringLen)
4424                         if intStringLen < 0 {
4425                                 return ErrInvalidLengthGenerated
4426                         }
4427                         postIndex := iNdEx + intStringLen
4428                         if postIndex > l {
4429                                 return io.ErrUnexpectedEOF
4430                         }
4431                         m.PathPrefix = string(dAtA[iNdEx:postIndex])
4432                         iNdEx = postIndex
4433                 case 2:
4434                         if wireType != 0 {
4435                                 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
4436                         }
4437                         var v int
4438                         for shift := uint(0); ; shift += 7 {
4439                                 if shift >= 64 {
4440                                         return ErrIntOverflowGenerated
4441                                 }
4442                                 if iNdEx >= l {
4443                                         return io.ErrUnexpectedEOF
4444                                 }
4445                                 b := dAtA[iNdEx]
4446                                 iNdEx++
4447                                 v |= (int(b) & 0x7F) << shift
4448                                 if b < 0x80 {
4449                                         break
4450                                 }
4451                         }
4452                         m.ReadOnly = bool(v != 0)
4453                 default:
4454                         iNdEx = preIndex
4455                         skippy, err := skipGenerated(dAtA[iNdEx:])
4456                         if err != nil {
4457                                 return err
4458                         }
4459                         if skippy < 0 {
4460                                 return ErrInvalidLengthGenerated
4461                         }
4462                         if (iNdEx + skippy) > l {
4463                                 return io.ErrUnexpectedEOF
4464                         }
4465                         iNdEx += skippy
4466                 }
4467         }
4468
4469         if iNdEx > l {
4470                 return io.ErrUnexpectedEOF
4471         }
4472         return nil
4473 }
4474 func (m *DaemonSet) Unmarshal(dAtA []byte) error {
4475         l := len(dAtA)
4476         iNdEx := 0
4477         for iNdEx < l {
4478                 preIndex := iNdEx
4479                 var wire uint64
4480                 for shift := uint(0); ; shift += 7 {
4481                         if shift >= 64 {
4482                                 return ErrIntOverflowGenerated
4483                         }
4484                         if iNdEx >= l {
4485                                 return io.ErrUnexpectedEOF
4486                         }
4487                         b := dAtA[iNdEx]
4488                         iNdEx++
4489                         wire |= (uint64(b) & 0x7F) << shift
4490                         if b < 0x80 {
4491                                 break
4492                         }
4493                 }
4494                 fieldNum := int32(wire >> 3)
4495                 wireType := int(wire & 0x7)
4496                 if wireType == 4 {
4497                         return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
4498                 }
4499                 if fieldNum <= 0 {
4500                         return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
4501                 }
4502                 switch fieldNum {
4503                 case 1:
4504                         if wireType != 2 {
4505                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4506                         }
4507                         var msglen int
4508                         for shift := uint(0); ; shift += 7 {
4509                                 if shift >= 64 {
4510                                         return ErrIntOverflowGenerated
4511                                 }
4512                                 if iNdEx >= l {
4513                                         return io.ErrUnexpectedEOF
4514                                 }
4515                                 b := dAtA[iNdEx]
4516                                 iNdEx++
4517                                 msglen |= (int(b) & 0x7F) << shift
4518                                 if b < 0x80 {
4519                                         break
4520                                 }
4521                         }
4522                         if msglen < 0 {
4523                                 return ErrInvalidLengthGenerated
4524                         }
4525                         postIndex := iNdEx + msglen
4526                         if postIndex > l {
4527                                 return io.ErrUnexpectedEOF
4528                         }
4529                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4530                                 return err
4531                         }
4532                         iNdEx = postIndex
4533                 case 2:
4534                         if wireType != 2 {
4535                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4536                         }
4537                         var msglen int
4538                         for shift := uint(0); ; shift += 7 {
4539                                 if shift >= 64 {
4540                                         return ErrIntOverflowGenerated
4541                                 }
4542                                 if iNdEx >= l {
4543                                         return io.ErrUnexpectedEOF
4544                                 }
4545                                 b := dAtA[iNdEx]
4546                                 iNdEx++
4547                                 msglen |= (int(b) & 0x7F) << shift
4548                                 if b < 0x80 {
4549                                         break
4550                                 }
4551                         }
4552                         if msglen < 0 {
4553                                 return ErrInvalidLengthGenerated
4554                         }
4555                         postIndex := iNdEx + msglen
4556                         if postIndex > l {
4557                                 return io.ErrUnexpectedEOF
4558                         }
4559                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4560                                 return err
4561                         }
4562                         iNdEx = postIndex
4563                 case 3:
4564                         if wireType != 2 {
4565                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4566                         }
4567                         var msglen int
4568                         for shift := uint(0); ; shift += 7 {
4569                                 if shift >= 64 {
4570                                         return ErrIntOverflowGenerated
4571                                 }
4572                                 if iNdEx >= l {
4573                                         return io.ErrUnexpectedEOF
4574                                 }
4575                                 b := dAtA[iNdEx]
4576                                 iNdEx++
4577                                 msglen |= (int(b) & 0x7F) << shift
4578                                 if b < 0x80 {
4579                                         break
4580                                 }
4581                         }
4582                         if msglen < 0 {
4583                                 return ErrInvalidLengthGenerated
4584                         }
4585                         postIndex := iNdEx + msglen
4586                         if postIndex > l {
4587                                 return io.ErrUnexpectedEOF
4588                         }
4589                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4590                                 return err
4591                         }
4592                         iNdEx = postIndex
4593                 default:
4594                         iNdEx = preIndex
4595                         skippy, err := skipGenerated(dAtA[iNdEx:])
4596                         if err != nil {
4597                                 return err
4598                         }
4599                         if skippy < 0 {
4600                                 return ErrInvalidLengthGenerated
4601                         }
4602                         if (iNdEx + skippy) > l {
4603                                 return io.ErrUnexpectedEOF
4604                         }
4605                         iNdEx += skippy
4606                 }
4607         }
4608
4609         if iNdEx > l {
4610                 return io.ErrUnexpectedEOF
4611         }
4612         return nil
4613 }
4614 func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error {
4615         l := len(dAtA)
4616         iNdEx := 0
4617         for iNdEx < l {
4618                 preIndex := iNdEx
4619                 var wire uint64
4620                 for shift := uint(0); ; shift += 7 {
4621                         if shift >= 64 {
4622                                 return ErrIntOverflowGenerated
4623                         }
4624                         if iNdEx >= l {
4625                                 return io.ErrUnexpectedEOF
4626                         }
4627                         b := dAtA[iNdEx]
4628                         iNdEx++
4629                         wire |= (uint64(b) & 0x7F) << shift
4630                         if b < 0x80 {
4631                                 break
4632                         }
4633                 }
4634                 fieldNum := int32(wire >> 3)
4635                 wireType := int(wire & 0x7)
4636                 if wireType == 4 {
4637                         return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group")
4638                 }
4639                 if fieldNum <= 0 {
4640                         return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4641                 }
4642                 switch fieldNum {
4643                 case 1:
4644                         if wireType != 2 {
4645                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4646                         }
4647                         var stringLen uint64
4648                         for shift := uint(0); ; shift += 7 {
4649                                 if shift >= 64 {
4650                                         return ErrIntOverflowGenerated
4651                                 }
4652                                 if iNdEx >= l {
4653                                         return io.ErrUnexpectedEOF
4654                                 }
4655                                 b := dAtA[iNdEx]
4656                                 iNdEx++
4657                                 stringLen |= (uint64(b) & 0x7F) << shift
4658                                 if b < 0x80 {
4659                                         break
4660                                 }
4661                         }
4662                         intStringLen := int(stringLen)
4663                         if intStringLen < 0 {
4664                                 return ErrInvalidLengthGenerated
4665                         }
4666                         postIndex := iNdEx + intStringLen
4667                         if postIndex > l {
4668                                 return io.ErrUnexpectedEOF
4669                         }
4670                         m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex])
4671                         iNdEx = postIndex
4672                 case 2:
4673                         if wireType != 2 {
4674                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4675                         }
4676                         var stringLen uint64
4677                         for shift := uint(0); ; shift += 7 {
4678                                 if shift >= 64 {
4679                                         return ErrIntOverflowGenerated
4680                                 }
4681                                 if iNdEx >= l {
4682                                         return io.ErrUnexpectedEOF
4683                                 }
4684                                 b := dAtA[iNdEx]
4685                                 iNdEx++
4686                                 stringLen |= (uint64(b) & 0x7F) << shift
4687                                 if b < 0x80 {
4688                                         break
4689                                 }
4690                         }
4691                         intStringLen := int(stringLen)
4692                         if intStringLen < 0 {
4693                                 return ErrInvalidLengthGenerated
4694                         }
4695                         postIndex := iNdEx + intStringLen
4696                         if postIndex > l {
4697                                 return io.ErrUnexpectedEOF
4698                         }
4699                         m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
4700                         iNdEx = postIndex
4701                 case 3:
4702                         if wireType != 2 {
4703                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4704                         }
4705                         var msglen int
4706                         for shift := uint(0); ; shift += 7 {
4707                                 if shift >= 64 {
4708                                         return ErrIntOverflowGenerated
4709                                 }
4710                                 if iNdEx >= l {
4711                                         return io.ErrUnexpectedEOF
4712                                 }
4713                                 b := dAtA[iNdEx]
4714                                 iNdEx++
4715                                 msglen |= (int(b) & 0x7F) << shift
4716                                 if b < 0x80 {
4717                                         break
4718                                 }
4719                         }
4720                         if msglen < 0 {
4721                                 return ErrInvalidLengthGenerated
4722                         }
4723                         postIndex := iNdEx + msglen
4724                         if postIndex > l {
4725                                 return io.ErrUnexpectedEOF
4726                         }
4727                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4728                                 return err
4729                         }
4730                         iNdEx = postIndex
4731                 case 4:
4732                         if wireType != 2 {
4733                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4734                         }
4735                         var stringLen uint64
4736                         for shift := uint(0); ; shift += 7 {
4737                                 if shift >= 64 {
4738                                         return ErrIntOverflowGenerated
4739                                 }
4740                                 if iNdEx >= l {
4741                                         return io.ErrUnexpectedEOF
4742                                 }
4743                                 b := dAtA[iNdEx]
4744                                 iNdEx++
4745                                 stringLen |= (uint64(b) & 0x7F) << shift
4746                                 if b < 0x80 {
4747                                         break
4748                                 }
4749                         }
4750                         intStringLen := int(stringLen)
4751                         if intStringLen < 0 {
4752                                 return ErrInvalidLengthGenerated
4753                         }
4754                         postIndex := iNdEx + intStringLen
4755                         if postIndex > l {
4756                                 return io.ErrUnexpectedEOF
4757                         }
4758                         m.Reason = string(dAtA[iNdEx:postIndex])
4759                         iNdEx = postIndex
4760                 case 5:
4761                         if wireType != 2 {
4762                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
4763                         }
4764                         var stringLen uint64
4765                         for shift := uint(0); ; shift += 7 {
4766                                 if shift >= 64 {
4767                                         return ErrIntOverflowGenerated
4768                                 }
4769                                 if iNdEx >= l {
4770                                         return io.ErrUnexpectedEOF
4771                                 }
4772                                 b := dAtA[iNdEx]
4773                                 iNdEx++
4774                                 stringLen |= (uint64(b) & 0x7F) << shift
4775                                 if b < 0x80 {
4776                                         break
4777                                 }
4778                         }
4779                         intStringLen := int(stringLen)
4780                         if intStringLen < 0 {
4781                                 return ErrInvalidLengthGenerated
4782                         }
4783                         postIndex := iNdEx + intStringLen
4784                         if postIndex > l {
4785                                 return io.ErrUnexpectedEOF
4786                         }
4787                         m.Message = string(dAtA[iNdEx:postIndex])
4788                         iNdEx = postIndex
4789                 default:
4790                         iNdEx = preIndex
4791                         skippy, err := skipGenerated(dAtA[iNdEx:])
4792                         if err != nil {
4793                                 return err
4794                         }
4795                         if skippy < 0 {
4796                                 return ErrInvalidLengthGenerated
4797                         }
4798                         if (iNdEx + skippy) > l {
4799                                 return io.ErrUnexpectedEOF
4800                         }
4801                         iNdEx += skippy
4802                 }
4803         }
4804
4805         if iNdEx > l {
4806                 return io.ErrUnexpectedEOF
4807         }
4808         return nil
4809 }
4810 func (m *DaemonSetList) Unmarshal(dAtA []byte) error {
4811         l := len(dAtA)
4812         iNdEx := 0
4813         for iNdEx < l {
4814                 preIndex := iNdEx
4815                 var wire uint64
4816                 for shift := uint(0); ; shift += 7 {
4817                         if shift >= 64 {
4818                                 return ErrIntOverflowGenerated
4819                         }
4820                         if iNdEx >= l {
4821                                 return io.ErrUnexpectedEOF
4822                         }
4823                         b := dAtA[iNdEx]
4824                         iNdEx++
4825                         wire |= (uint64(b) & 0x7F) << shift
4826                         if b < 0x80 {
4827                                 break
4828                         }
4829                 }
4830                 fieldNum := int32(wire >> 3)
4831                 wireType := int(wire & 0x7)
4832                 if wireType == 4 {
4833                         return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
4834                 }
4835                 if fieldNum <= 0 {
4836                         return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
4837                 }
4838                 switch fieldNum {
4839                 case 1:
4840                         if wireType != 2 {
4841                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4842                         }
4843                         var msglen int
4844                         for shift := uint(0); ; shift += 7 {
4845                                 if shift >= 64 {
4846                                         return ErrIntOverflowGenerated
4847                                 }
4848                                 if iNdEx >= l {
4849                                         return io.ErrUnexpectedEOF
4850                                 }
4851                                 b := dAtA[iNdEx]
4852                                 iNdEx++
4853                                 msglen |= (int(b) & 0x7F) << shift
4854                                 if b < 0x80 {
4855                                         break
4856                                 }
4857                         }
4858                         if msglen < 0 {
4859                                 return ErrInvalidLengthGenerated
4860                         }
4861                         postIndex := iNdEx + msglen
4862                         if postIndex > l {
4863                                 return io.ErrUnexpectedEOF
4864                         }
4865                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4866                                 return err
4867                         }
4868                         iNdEx = postIndex
4869                 case 2:
4870                         if wireType != 2 {
4871                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4872                         }
4873                         var msglen int
4874                         for shift := uint(0); ; shift += 7 {
4875                                 if shift >= 64 {
4876                                         return ErrIntOverflowGenerated
4877                                 }
4878                                 if iNdEx >= l {
4879                                         return io.ErrUnexpectedEOF
4880                                 }
4881                                 b := dAtA[iNdEx]
4882                                 iNdEx++
4883                                 msglen |= (int(b) & 0x7F) << shift
4884                                 if b < 0x80 {
4885                                         break
4886                                 }
4887                         }
4888                         if msglen < 0 {
4889                                 return ErrInvalidLengthGenerated
4890                         }
4891                         postIndex := iNdEx + msglen
4892                         if postIndex > l {
4893                                 return io.ErrUnexpectedEOF
4894                         }
4895                         m.Items = append(m.Items, DaemonSet{})
4896                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4897                                 return err
4898                         }
4899                         iNdEx = postIndex
4900                 default:
4901                         iNdEx = preIndex
4902                         skippy, err := skipGenerated(dAtA[iNdEx:])
4903                         if err != nil {
4904                                 return err
4905                         }
4906                         if skippy < 0 {
4907                                 return ErrInvalidLengthGenerated
4908                         }
4909                         if (iNdEx + skippy) > l {
4910                                 return io.ErrUnexpectedEOF
4911                         }
4912                         iNdEx += skippy
4913                 }
4914         }
4915
4916         if iNdEx > l {
4917                 return io.ErrUnexpectedEOF
4918         }
4919         return nil
4920 }
4921 func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error {
4922         l := len(dAtA)
4923         iNdEx := 0
4924         for iNdEx < l {
4925                 preIndex := iNdEx
4926                 var wire uint64
4927                 for shift := uint(0); ; shift += 7 {
4928                         if shift >= 64 {
4929                                 return ErrIntOverflowGenerated
4930                         }
4931                         if iNdEx >= l {
4932                                 return io.ErrUnexpectedEOF
4933                         }
4934                         b := dAtA[iNdEx]
4935                         iNdEx++
4936                         wire |= (uint64(b) & 0x7F) << shift
4937                         if b < 0x80 {
4938                                 break
4939                         }
4940                 }
4941                 fieldNum := int32(wire >> 3)
4942                 wireType := int(wire & 0x7)
4943                 if wireType == 4 {
4944                         return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
4945                 }
4946                 if fieldNum <= 0 {
4947                         return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4948                 }
4949                 switch fieldNum {
4950                 case 1:
4951                         if wireType != 2 {
4952                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
4953                         }
4954                         var msglen int
4955                         for shift := uint(0); ; shift += 7 {
4956                                 if shift >= 64 {
4957                                         return ErrIntOverflowGenerated
4958                                 }
4959                                 if iNdEx >= l {
4960                                         return io.ErrUnexpectedEOF
4961                                 }
4962                                 b := dAtA[iNdEx]
4963                                 iNdEx++
4964                                 msglen |= (int(b) & 0x7F) << shift
4965                                 if b < 0x80 {
4966                                         break
4967                                 }
4968                         }
4969                         if msglen < 0 {
4970                                 return ErrInvalidLengthGenerated
4971                         }
4972                         postIndex := iNdEx + msglen
4973                         if postIndex > l {
4974                                 return io.ErrUnexpectedEOF
4975                         }
4976                         if m.Selector == nil {
4977                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
4978                         }
4979                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4980                                 return err
4981                         }
4982                         iNdEx = postIndex
4983                 case 2:
4984                         if wireType != 2 {
4985                                 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
4986                         }
4987                         var msglen int
4988                         for shift := uint(0); ; shift += 7 {
4989                                 if shift >= 64 {
4990                                         return ErrIntOverflowGenerated
4991                                 }
4992                                 if iNdEx >= l {
4993                                         return io.ErrUnexpectedEOF
4994                                 }
4995                                 b := dAtA[iNdEx]
4996                                 iNdEx++
4997                                 msglen |= (int(b) & 0x7F) << shift
4998                                 if b < 0x80 {
4999                                         break
5000                                 }
5001                         }
5002                         if msglen < 0 {
5003                                 return ErrInvalidLengthGenerated
5004                         }
5005                         postIndex := iNdEx + msglen
5006                         if postIndex > l {
5007                                 return io.ErrUnexpectedEOF
5008                         }
5009                         if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5010                                 return err
5011                         }
5012                         iNdEx = postIndex
5013                 case 3:
5014                         if wireType != 2 {
5015                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
5016                         }
5017                         var msglen int
5018                         for shift := uint(0); ; shift += 7 {
5019                                 if shift >= 64 {
5020                                         return ErrIntOverflowGenerated
5021                                 }
5022                                 if iNdEx >= l {
5023                                         return io.ErrUnexpectedEOF
5024                                 }
5025                                 b := dAtA[iNdEx]
5026                                 iNdEx++
5027                                 msglen |= (int(b) & 0x7F) << shift
5028                                 if b < 0x80 {
5029                                         break
5030                                 }
5031                         }
5032                         if msglen < 0 {
5033                                 return ErrInvalidLengthGenerated
5034                         }
5035                         postIndex := iNdEx + msglen
5036                         if postIndex > l {
5037                                 return io.ErrUnexpectedEOF
5038                         }
5039                         if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5040                                 return err
5041                         }
5042                         iNdEx = postIndex
5043                 case 4:
5044                         if wireType != 0 {
5045                                 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
5046                         }
5047                         m.MinReadySeconds = 0
5048                         for shift := uint(0); ; shift += 7 {
5049                                 if shift >= 64 {
5050                                         return ErrIntOverflowGenerated
5051                                 }
5052                                 if iNdEx >= l {
5053                                         return io.ErrUnexpectedEOF
5054                                 }
5055                                 b := dAtA[iNdEx]
5056                                 iNdEx++
5057                                 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
5058                                 if b < 0x80 {
5059                                         break
5060                                 }
5061                         }
5062                 case 5:
5063                         if wireType != 0 {
5064                                 return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType)
5065                         }
5066                         m.TemplateGeneration = 0
5067                         for shift := uint(0); ; shift += 7 {
5068                                 if shift >= 64 {
5069                                         return ErrIntOverflowGenerated
5070                                 }
5071                                 if iNdEx >= l {
5072                                         return io.ErrUnexpectedEOF
5073                                 }
5074                                 b := dAtA[iNdEx]
5075                                 iNdEx++
5076                                 m.TemplateGeneration |= (int64(b) & 0x7F) << shift
5077                                 if b < 0x80 {
5078                                         break
5079                                 }
5080                         }
5081                 case 6:
5082                         if wireType != 0 {
5083                                 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
5084                         }
5085                         var v int32
5086                         for shift := uint(0); ; shift += 7 {
5087                                 if shift >= 64 {
5088                                         return ErrIntOverflowGenerated
5089                                 }
5090                                 if iNdEx >= l {
5091                                         return io.ErrUnexpectedEOF
5092                                 }
5093                                 b := dAtA[iNdEx]
5094                                 iNdEx++
5095                                 v |= (int32(b) & 0x7F) << shift
5096                                 if b < 0x80 {
5097                                         break
5098                                 }
5099                         }
5100                         m.RevisionHistoryLimit = &v
5101                 default:
5102                         iNdEx = preIndex
5103                         skippy, err := skipGenerated(dAtA[iNdEx:])
5104                         if err != nil {
5105                                 return err
5106                         }
5107                         if skippy < 0 {
5108                                 return ErrInvalidLengthGenerated
5109                         }
5110                         if (iNdEx + skippy) > l {
5111                                 return io.ErrUnexpectedEOF
5112                         }
5113                         iNdEx += skippy
5114                 }
5115         }
5116
5117         if iNdEx > l {
5118                 return io.ErrUnexpectedEOF
5119         }
5120         return nil
5121 }
5122 func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error {
5123         l := len(dAtA)
5124         iNdEx := 0
5125         for iNdEx < l {
5126                 preIndex := iNdEx
5127                 var wire uint64
5128                 for shift := uint(0); ; shift += 7 {
5129                         if shift >= 64 {
5130                                 return ErrIntOverflowGenerated
5131                         }
5132                         if iNdEx >= l {
5133                                 return io.ErrUnexpectedEOF
5134                         }
5135                         b := dAtA[iNdEx]
5136                         iNdEx++
5137                         wire |= (uint64(b) & 0x7F) << shift
5138                         if b < 0x80 {
5139                                 break
5140                         }
5141                 }
5142                 fieldNum := int32(wire >> 3)
5143                 wireType := int(wire & 0x7)
5144                 if wireType == 4 {
5145                         return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
5146                 }
5147                 if fieldNum <= 0 {
5148                         return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5149                 }
5150                 switch fieldNum {
5151                 case 1:
5152                         if wireType != 0 {
5153                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
5154                         }
5155                         m.CurrentNumberScheduled = 0
5156                         for shift := uint(0); ; shift += 7 {
5157                                 if shift >= 64 {
5158                                         return ErrIntOverflowGenerated
5159                                 }
5160                                 if iNdEx >= l {
5161                                         return io.ErrUnexpectedEOF
5162                                 }
5163                                 b := dAtA[iNdEx]
5164                                 iNdEx++
5165                                 m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift
5166                                 if b < 0x80 {
5167                                         break
5168                                 }
5169                         }
5170                 case 2:
5171                         if wireType != 0 {
5172                                 return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
5173                         }
5174                         m.NumberMisscheduled = 0
5175                         for shift := uint(0); ; shift += 7 {
5176                                 if shift >= 64 {
5177                                         return ErrIntOverflowGenerated
5178                                 }
5179                                 if iNdEx >= l {
5180                                         return io.ErrUnexpectedEOF
5181                                 }
5182                                 b := dAtA[iNdEx]
5183                                 iNdEx++
5184                                 m.NumberMisscheduled |= (int32(b) & 0x7F) << shift
5185                                 if b < 0x80 {
5186                                         break
5187                                 }
5188                         }
5189                 case 3:
5190                         if wireType != 0 {
5191                                 return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
5192                         }
5193                         m.DesiredNumberScheduled = 0
5194                         for shift := uint(0); ; shift += 7 {
5195                                 if shift >= 64 {
5196                                         return ErrIntOverflowGenerated
5197                                 }
5198                                 if iNdEx >= l {
5199                                         return io.ErrUnexpectedEOF
5200                                 }
5201                                 b := dAtA[iNdEx]
5202                                 iNdEx++
5203                                 m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift
5204                                 if b < 0x80 {
5205                                         break
5206                                 }
5207                         }
5208                 case 4:
5209                         if wireType != 0 {
5210                                 return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType)
5211                         }
5212                         m.NumberReady = 0
5213                         for shift := uint(0); ; shift += 7 {
5214                                 if shift >= 64 {
5215                                         return ErrIntOverflowGenerated
5216                                 }
5217                                 if iNdEx >= l {
5218                                         return io.ErrUnexpectedEOF
5219                                 }
5220                                 b := dAtA[iNdEx]
5221                                 iNdEx++
5222                                 m.NumberReady |= (int32(b) & 0x7F) << shift
5223                                 if b < 0x80 {
5224                                         break
5225                                 }
5226                         }
5227                 case 5:
5228                         if wireType != 0 {
5229                                 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
5230                         }
5231                         m.ObservedGeneration = 0
5232                         for shift := uint(0); ; shift += 7 {
5233                                 if shift >= 64 {
5234                                         return ErrIntOverflowGenerated
5235                                 }
5236                                 if iNdEx >= l {
5237                                         return io.ErrUnexpectedEOF
5238                                 }
5239                                 b := dAtA[iNdEx]
5240                                 iNdEx++
5241                                 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
5242                                 if b < 0x80 {
5243                                         break
5244                                 }
5245                         }
5246                 case 6:
5247                         if wireType != 0 {
5248                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType)
5249                         }
5250                         m.UpdatedNumberScheduled = 0
5251                         for shift := uint(0); ; shift += 7 {
5252                                 if shift >= 64 {
5253                                         return ErrIntOverflowGenerated
5254                                 }
5255                                 if iNdEx >= l {
5256                                         return io.ErrUnexpectedEOF
5257                                 }
5258                                 b := dAtA[iNdEx]
5259                                 iNdEx++
5260                                 m.UpdatedNumberScheduled |= (int32(b) & 0x7F) << shift
5261                                 if b < 0x80 {
5262                                         break
5263                                 }
5264                         }
5265                 case 7:
5266                         if wireType != 0 {
5267                                 return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType)
5268                         }
5269                         m.NumberAvailable = 0
5270                         for shift := uint(0); ; shift += 7 {
5271                                 if shift >= 64 {
5272                                         return ErrIntOverflowGenerated
5273                                 }
5274                                 if iNdEx >= l {
5275                                         return io.ErrUnexpectedEOF
5276                                 }
5277                                 b := dAtA[iNdEx]
5278                                 iNdEx++
5279                                 m.NumberAvailable |= (int32(b) & 0x7F) << shift
5280                                 if b < 0x80 {
5281                                         break
5282                                 }
5283                         }
5284                 case 8:
5285                         if wireType != 0 {
5286                                 return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType)
5287                         }
5288                         m.NumberUnavailable = 0
5289                         for shift := uint(0); ; shift += 7 {
5290                                 if shift >= 64 {
5291                                         return ErrIntOverflowGenerated
5292                                 }
5293                                 if iNdEx >= l {
5294                                         return io.ErrUnexpectedEOF
5295                                 }
5296                                 b := dAtA[iNdEx]
5297                                 iNdEx++
5298                                 m.NumberUnavailable |= (int32(b) & 0x7F) << shift
5299                                 if b < 0x80 {
5300                                         break
5301                                 }
5302                         }
5303                 case 9:
5304                         if wireType != 0 {
5305                                 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
5306                         }
5307                         var v int32
5308                         for shift := uint(0); ; shift += 7 {
5309                                 if shift >= 64 {
5310                                         return ErrIntOverflowGenerated
5311                                 }
5312                                 if iNdEx >= l {
5313                                         return io.ErrUnexpectedEOF
5314                                 }
5315                                 b := dAtA[iNdEx]
5316                                 iNdEx++
5317                                 v |= (int32(b) & 0x7F) << shift
5318                                 if b < 0x80 {
5319                                         break
5320                                 }
5321                         }
5322                         m.CollisionCount = &v
5323                 case 10:
5324                         if wireType != 2 {
5325                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
5326                         }
5327                         var msglen int
5328                         for shift := uint(0); ; shift += 7 {
5329                                 if shift >= 64 {
5330                                         return ErrIntOverflowGenerated
5331                                 }
5332                                 if iNdEx >= l {
5333                                         return io.ErrUnexpectedEOF
5334                                 }
5335                                 b := dAtA[iNdEx]
5336                                 iNdEx++
5337                                 msglen |= (int(b) & 0x7F) << shift
5338                                 if b < 0x80 {
5339                                         break
5340                                 }
5341                         }
5342                         if msglen < 0 {
5343                                 return ErrInvalidLengthGenerated
5344                         }
5345                         postIndex := iNdEx + msglen
5346                         if postIndex > l {
5347                                 return io.ErrUnexpectedEOF
5348                         }
5349                         m.Conditions = append(m.Conditions, DaemonSetCondition{})
5350                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5351                                 return err
5352                         }
5353                         iNdEx = postIndex
5354                 default:
5355                         iNdEx = preIndex
5356                         skippy, err := skipGenerated(dAtA[iNdEx:])
5357                         if err != nil {
5358                                 return err
5359                         }
5360                         if skippy < 0 {
5361                                 return ErrInvalidLengthGenerated
5362                         }
5363                         if (iNdEx + skippy) > l {
5364                                 return io.ErrUnexpectedEOF
5365                         }
5366                         iNdEx += skippy
5367                 }
5368         }
5369
5370         if iNdEx > l {
5371                 return io.ErrUnexpectedEOF
5372         }
5373         return nil
5374 }
5375 func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error {
5376         l := len(dAtA)
5377         iNdEx := 0
5378         for iNdEx < l {
5379                 preIndex := iNdEx
5380                 var wire uint64
5381                 for shift := uint(0); ; shift += 7 {
5382                         if shift >= 64 {
5383                                 return ErrIntOverflowGenerated
5384                         }
5385                         if iNdEx >= l {
5386                                 return io.ErrUnexpectedEOF
5387                         }
5388                         b := dAtA[iNdEx]
5389                         iNdEx++
5390                         wire |= (uint64(b) & 0x7F) << shift
5391                         if b < 0x80 {
5392                                 break
5393                         }
5394                 }
5395                 fieldNum := int32(wire >> 3)
5396                 wireType := int(wire & 0x7)
5397                 if wireType == 4 {
5398                         return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group")
5399                 }
5400                 if fieldNum <= 0 {
5401                         return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
5402                 }
5403                 switch fieldNum {
5404                 case 1:
5405                         if wireType != 2 {
5406                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5407                         }
5408                         var stringLen uint64
5409                         for shift := uint(0); ; shift += 7 {
5410                                 if shift >= 64 {
5411                                         return ErrIntOverflowGenerated
5412                                 }
5413                                 if iNdEx >= l {
5414                                         return io.ErrUnexpectedEOF
5415                                 }
5416                                 b := dAtA[iNdEx]
5417                                 iNdEx++
5418                                 stringLen |= (uint64(b) & 0x7F) << shift
5419                                 if b < 0x80 {
5420                                         break
5421                                 }
5422                         }
5423                         intStringLen := int(stringLen)
5424                         if intStringLen < 0 {
5425                                 return ErrInvalidLengthGenerated
5426                         }
5427                         postIndex := iNdEx + intStringLen
5428                         if postIndex > l {
5429                                 return io.ErrUnexpectedEOF
5430                         }
5431                         m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex])
5432                         iNdEx = postIndex
5433                 case 2:
5434                         if wireType != 2 {
5435                                 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
5436                         }
5437                         var msglen int
5438                         for shift := uint(0); ; shift += 7 {
5439                                 if shift >= 64 {
5440                                         return ErrIntOverflowGenerated
5441                                 }
5442                                 if iNdEx >= l {
5443                                         return io.ErrUnexpectedEOF
5444                                 }
5445                                 b := dAtA[iNdEx]
5446                                 iNdEx++
5447                                 msglen |= (int(b) & 0x7F) << shift
5448                                 if b < 0x80 {
5449                                         break
5450                                 }
5451                         }
5452                         if msglen < 0 {
5453                                 return ErrInvalidLengthGenerated
5454                         }
5455                         postIndex := iNdEx + msglen
5456                         if postIndex > l {
5457                                 return io.ErrUnexpectedEOF
5458                         }
5459                         if m.RollingUpdate == nil {
5460                                 m.RollingUpdate = &RollingUpdateDaemonSet{}
5461                         }
5462                         if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5463                                 return err
5464                         }
5465                         iNdEx = postIndex
5466                 default:
5467                         iNdEx = preIndex
5468                         skippy, err := skipGenerated(dAtA[iNdEx:])
5469                         if err != nil {
5470                                 return err
5471                         }
5472                         if skippy < 0 {
5473                                 return ErrInvalidLengthGenerated
5474                         }
5475                         if (iNdEx + skippy) > l {
5476                                 return io.ErrUnexpectedEOF
5477                         }
5478                         iNdEx += skippy
5479                 }
5480         }
5481
5482         if iNdEx > l {
5483                 return io.ErrUnexpectedEOF
5484         }
5485         return nil
5486 }
5487 func (m *Deployment) Unmarshal(dAtA []byte) error {
5488         l := len(dAtA)
5489         iNdEx := 0
5490         for iNdEx < l {
5491                 preIndex := iNdEx
5492                 var wire uint64
5493                 for shift := uint(0); ; shift += 7 {
5494                         if shift >= 64 {
5495                                 return ErrIntOverflowGenerated
5496                         }
5497                         if iNdEx >= l {
5498                                 return io.ErrUnexpectedEOF
5499                         }
5500                         b := dAtA[iNdEx]
5501                         iNdEx++
5502                         wire |= (uint64(b) & 0x7F) << shift
5503                         if b < 0x80 {
5504                                 break
5505                         }
5506                 }
5507                 fieldNum := int32(wire >> 3)
5508                 wireType := int(wire & 0x7)
5509                 if wireType == 4 {
5510                         return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
5511                 }
5512                 if fieldNum <= 0 {
5513                         return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
5514                 }
5515                 switch fieldNum {
5516                 case 1:
5517                         if wireType != 2 {
5518                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
5519                         }
5520                         var msglen int
5521                         for shift := uint(0); ; shift += 7 {
5522                                 if shift >= 64 {
5523                                         return ErrIntOverflowGenerated
5524                                 }
5525                                 if iNdEx >= l {
5526                                         return io.ErrUnexpectedEOF
5527                                 }
5528                                 b := dAtA[iNdEx]
5529                                 iNdEx++
5530                                 msglen |= (int(b) & 0x7F) << shift
5531                                 if b < 0x80 {
5532                                         break
5533                                 }
5534                         }
5535                         if msglen < 0 {
5536                                 return ErrInvalidLengthGenerated
5537                         }
5538                         postIndex := iNdEx + msglen
5539                         if postIndex > l {
5540                                 return io.ErrUnexpectedEOF
5541                         }
5542                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5543                                 return err
5544                         }
5545                         iNdEx = postIndex
5546                 case 2:
5547                         if wireType != 2 {
5548                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
5549                         }
5550                         var msglen int
5551                         for shift := uint(0); ; shift += 7 {
5552                                 if shift >= 64 {
5553                                         return ErrIntOverflowGenerated
5554                                 }
5555                                 if iNdEx >= l {
5556                                         return io.ErrUnexpectedEOF
5557                                 }
5558                                 b := dAtA[iNdEx]
5559                                 iNdEx++
5560                                 msglen |= (int(b) & 0x7F) << shift
5561                                 if b < 0x80 {
5562                                         break
5563                                 }
5564                         }
5565                         if msglen < 0 {
5566                                 return ErrInvalidLengthGenerated
5567                         }
5568                         postIndex := iNdEx + msglen
5569                         if postIndex > l {
5570                                 return io.ErrUnexpectedEOF
5571                         }
5572                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5573                                 return err
5574                         }
5575                         iNdEx = postIndex
5576                 case 3:
5577                         if wireType != 2 {
5578                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5579                         }
5580                         var msglen int
5581                         for shift := uint(0); ; shift += 7 {
5582                                 if shift >= 64 {
5583                                         return ErrIntOverflowGenerated
5584                                 }
5585                                 if iNdEx >= l {
5586                                         return io.ErrUnexpectedEOF
5587                                 }
5588                                 b := dAtA[iNdEx]
5589                                 iNdEx++
5590                                 msglen |= (int(b) & 0x7F) << shift
5591                                 if b < 0x80 {
5592                                         break
5593                                 }
5594                         }
5595                         if msglen < 0 {
5596                                 return ErrInvalidLengthGenerated
5597                         }
5598                         postIndex := iNdEx + msglen
5599                         if postIndex > l {
5600                                 return io.ErrUnexpectedEOF
5601                         }
5602                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5603                                 return err
5604                         }
5605                         iNdEx = postIndex
5606                 default:
5607                         iNdEx = preIndex
5608                         skippy, err := skipGenerated(dAtA[iNdEx:])
5609                         if err != nil {
5610                                 return err
5611                         }
5612                         if skippy < 0 {
5613                                 return ErrInvalidLengthGenerated
5614                         }
5615                         if (iNdEx + skippy) > l {
5616                                 return io.ErrUnexpectedEOF
5617                         }
5618                         iNdEx += skippy
5619                 }
5620         }
5621
5622         if iNdEx > l {
5623                 return io.ErrUnexpectedEOF
5624         }
5625         return nil
5626 }
5627 func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
5628         l := len(dAtA)
5629         iNdEx := 0
5630         for iNdEx < l {
5631                 preIndex := iNdEx
5632                 var wire uint64
5633                 for shift := uint(0); ; shift += 7 {
5634                         if shift >= 64 {
5635                                 return ErrIntOverflowGenerated
5636                         }
5637                         if iNdEx >= l {
5638                                 return io.ErrUnexpectedEOF
5639                         }
5640                         b := dAtA[iNdEx]
5641                         iNdEx++
5642                         wire |= (uint64(b) & 0x7F) << shift
5643                         if b < 0x80 {
5644                                 break
5645                         }
5646                 }
5647                 fieldNum := int32(wire >> 3)
5648                 wireType := int(wire & 0x7)
5649                 if wireType == 4 {
5650                         return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
5651                 }
5652                 if fieldNum <= 0 {
5653                         return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
5654                 }
5655                 switch fieldNum {
5656                 case 1:
5657                         if wireType != 2 {
5658                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5659                         }
5660                         var stringLen uint64
5661                         for shift := uint(0); ; shift += 7 {
5662                                 if shift >= 64 {
5663                                         return ErrIntOverflowGenerated
5664                                 }
5665                                 if iNdEx >= l {
5666                                         return io.ErrUnexpectedEOF
5667                                 }
5668                                 b := dAtA[iNdEx]
5669                                 iNdEx++
5670                                 stringLen |= (uint64(b) & 0x7F) << shift
5671                                 if b < 0x80 {
5672                                         break
5673                                 }
5674                         }
5675                         intStringLen := int(stringLen)
5676                         if intStringLen < 0 {
5677                                 return ErrInvalidLengthGenerated
5678                         }
5679                         postIndex := iNdEx + intStringLen
5680                         if postIndex > l {
5681                                 return io.ErrUnexpectedEOF
5682                         }
5683                         m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
5684                         iNdEx = postIndex
5685                 case 2:
5686                         if wireType != 2 {
5687                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5688                         }
5689                         var stringLen uint64
5690                         for shift := uint(0); ; shift += 7 {
5691                                 if shift >= 64 {
5692                                         return ErrIntOverflowGenerated
5693                                 }
5694                                 if iNdEx >= l {
5695                                         return io.ErrUnexpectedEOF
5696                                 }
5697                                 b := dAtA[iNdEx]
5698                                 iNdEx++
5699                                 stringLen |= (uint64(b) & 0x7F) << shift
5700                                 if b < 0x80 {
5701                                         break
5702                                 }
5703                         }
5704                         intStringLen := int(stringLen)
5705                         if intStringLen < 0 {
5706                                 return ErrInvalidLengthGenerated
5707                         }
5708                         postIndex := iNdEx + intStringLen
5709                         if postIndex > l {
5710                                 return io.ErrUnexpectedEOF
5711                         }
5712                         m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
5713                         iNdEx = postIndex
5714                 case 4:
5715                         if wireType != 2 {
5716                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5717                         }
5718                         var stringLen uint64
5719                         for shift := uint(0); ; shift += 7 {
5720                                 if shift >= 64 {
5721                                         return ErrIntOverflowGenerated
5722                                 }
5723                                 if iNdEx >= l {
5724                                         return io.ErrUnexpectedEOF
5725                                 }
5726                                 b := dAtA[iNdEx]
5727                                 iNdEx++
5728                                 stringLen |= (uint64(b) & 0x7F) << shift
5729                                 if b < 0x80 {
5730                                         break
5731                                 }
5732                         }
5733                         intStringLen := int(stringLen)
5734                         if intStringLen < 0 {
5735                                 return ErrInvalidLengthGenerated
5736                         }
5737                         postIndex := iNdEx + intStringLen
5738                         if postIndex > l {
5739                                 return io.ErrUnexpectedEOF
5740                         }
5741                         m.Reason = string(dAtA[iNdEx:postIndex])
5742                         iNdEx = postIndex
5743                 case 5:
5744                         if wireType != 2 {
5745                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5746                         }
5747                         var stringLen uint64
5748                         for shift := uint(0); ; shift += 7 {
5749                                 if shift >= 64 {
5750                                         return ErrIntOverflowGenerated
5751                                 }
5752                                 if iNdEx >= l {
5753                                         return io.ErrUnexpectedEOF
5754                                 }
5755                                 b := dAtA[iNdEx]
5756                                 iNdEx++
5757                                 stringLen |= (uint64(b) & 0x7F) << shift
5758                                 if b < 0x80 {
5759                                         break
5760                                 }
5761                         }
5762                         intStringLen := int(stringLen)
5763                         if intStringLen < 0 {
5764                                 return ErrInvalidLengthGenerated
5765                         }
5766                         postIndex := iNdEx + intStringLen
5767                         if postIndex > l {
5768                                 return io.ErrUnexpectedEOF
5769                         }
5770                         m.Message = string(dAtA[iNdEx:postIndex])
5771                         iNdEx = postIndex
5772                 case 6:
5773                         if wireType != 2 {
5774                                 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
5775                         }
5776                         var msglen int
5777                         for shift := uint(0); ; shift += 7 {
5778                                 if shift >= 64 {
5779                                         return ErrIntOverflowGenerated
5780                                 }
5781                                 if iNdEx >= l {
5782                                         return io.ErrUnexpectedEOF
5783                                 }
5784                                 b := dAtA[iNdEx]
5785                                 iNdEx++
5786                                 msglen |= (int(b) & 0x7F) << shift
5787                                 if b < 0x80 {
5788                                         break
5789                                 }
5790                         }
5791                         if msglen < 0 {
5792                                 return ErrInvalidLengthGenerated
5793                         }
5794                         postIndex := iNdEx + msglen
5795                         if postIndex > l {
5796                                 return io.ErrUnexpectedEOF
5797                         }
5798                         if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5799                                 return err
5800                         }
5801                         iNdEx = postIndex
5802                 case 7:
5803                         if wireType != 2 {
5804                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
5805                         }
5806                         var msglen int
5807                         for shift := uint(0); ; shift += 7 {
5808                                 if shift >= 64 {
5809                                         return ErrIntOverflowGenerated
5810                                 }
5811                                 if iNdEx >= l {
5812                                         return io.ErrUnexpectedEOF
5813                                 }
5814                                 b := dAtA[iNdEx]
5815                                 iNdEx++
5816                                 msglen |= (int(b) & 0x7F) << shift
5817                                 if b < 0x80 {
5818                                         break
5819                                 }
5820                         }
5821                         if msglen < 0 {
5822                                 return ErrInvalidLengthGenerated
5823                         }
5824                         postIndex := iNdEx + msglen
5825                         if postIndex > l {
5826                                 return io.ErrUnexpectedEOF
5827                         }
5828                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5829                                 return err
5830                         }
5831                         iNdEx = postIndex
5832                 default:
5833                         iNdEx = preIndex
5834                         skippy, err := skipGenerated(dAtA[iNdEx:])
5835                         if err != nil {
5836                                 return err
5837                         }
5838                         if skippy < 0 {
5839                                 return ErrInvalidLengthGenerated
5840                         }
5841                         if (iNdEx + skippy) > l {
5842                                 return io.ErrUnexpectedEOF
5843                         }
5844                         iNdEx += skippy
5845                 }
5846         }
5847
5848         if iNdEx > l {
5849                 return io.ErrUnexpectedEOF
5850         }
5851         return nil
5852 }
5853 func (m *DeploymentList) Unmarshal(dAtA []byte) error {
5854         l := len(dAtA)
5855         iNdEx := 0
5856         for iNdEx < l {
5857                 preIndex := iNdEx
5858                 var wire uint64
5859                 for shift := uint(0); ; shift += 7 {
5860                         if shift >= 64 {
5861                                 return ErrIntOverflowGenerated
5862                         }
5863                         if iNdEx >= l {
5864                                 return io.ErrUnexpectedEOF
5865                         }
5866                         b := dAtA[iNdEx]
5867                         iNdEx++
5868                         wire |= (uint64(b) & 0x7F) << shift
5869                         if b < 0x80 {
5870                                 break
5871                         }
5872                 }
5873                 fieldNum := int32(wire >> 3)
5874                 wireType := int(wire & 0x7)
5875                 if wireType == 4 {
5876                         return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
5877                 }
5878                 if fieldNum <= 0 {
5879                         return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
5880                 }
5881                 switch fieldNum {
5882                 case 1:
5883                         if wireType != 2 {
5884                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5885                         }
5886                         var msglen int
5887                         for shift := uint(0); ; shift += 7 {
5888                                 if shift >= 64 {
5889                                         return ErrIntOverflowGenerated
5890                                 }
5891                                 if iNdEx >= l {
5892                                         return io.ErrUnexpectedEOF
5893                                 }
5894                                 b := dAtA[iNdEx]
5895                                 iNdEx++
5896                                 msglen |= (int(b) & 0x7F) << shift
5897                                 if b < 0x80 {
5898                                         break
5899                                 }
5900                         }
5901                         if msglen < 0 {
5902                                 return ErrInvalidLengthGenerated
5903                         }
5904                         postIndex := iNdEx + msglen
5905                         if postIndex > l {
5906                                 return io.ErrUnexpectedEOF
5907                         }
5908                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5909                                 return err
5910                         }
5911                         iNdEx = postIndex
5912                 case 2:
5913                         if wireType != 2 {
5914                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5915                         }
5916                         var msglen int
5917                         for shift := uint(0); ; shift += 7 {
5918                                 if shift >= 64 {
5919                                         return ErrIntOverflowGenerated
5920                                 }
5921                                 if iNdEx >= l {
5922                                         return io.ErrUnexpectedEOF
5923                                 }
5924                                 b := dAtA[iNdEx]
5925                                 iNdEx++
5926                                 msglen |= (int(b) & 0x7F) << shift
5927                                 if b < 0x80 {
5928                                         break
5929                                 }
5930                         }
5931                         if msglen < 0 {
5932                                 return ErrInvalidLengthGenerated
5933                         }
5934                         postIndex := iNdEx + msglen
5935                         if postIndex > l {
5936                                 return io.ErrUnexpectedEOF
5937                         }
5938                         m.Items = append(m.Items, Deployment{})
5939                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5940                                 return err
5941                         }
5942                         iNdEx = postIndex
5943                 default:
5944                         iNdEx = preIndex
5945                         skippy, err := skipGenerated(dAtA[iNdEx:])
5946                         if err != nil {
5947                                 return err
5948                         }
5949                         if skippy < 0 {
5950                                 return ErrInvalidLengthGenerated
5951                         }
5952                         if (iNdEx + skippy) > l {
5953                                 return io.ErrUnexpectedEOF
5954                         }
5955                         iNdEx += skippy
5956                 }
5957         }
5958
5959         if iNdEx > l {
5960                 return io.ErrUnexpectedEOF
5961         }
5962         return nil
5963 }
5964 func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
5965         l := len(dAtA)
5966         iNdEx := 0
5967         for iNdEx < l {
5968                 preIndex := iNdEx
5969                 var wire uint64
5970                 for shift := uint(0); ; shift += 7 {
5971                         if shift >= 64 {
5972                                 return ErrIntOverflowGenerated
5973                         }
5974                         if iNdEx >= l {
5975                                 return io.ErrUnexpectedEOF
5976                         }
5977                         b := dAtA[iNdEx]
5978                         iNdEx++
5979                         wire |= (uint64(b) & 0x7F) << shift
5980                         if b < 0x80 {
5981                                 break
5982                         }
5983                 }
5984                 fieldNum := int32(wire >> 3)
5985                 wireType := int(wire & 0x7)
5986                 if wireType == 4 {
5987                         return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
5988                 }
5989                 if fieldNum <= 0 {
5990                         return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
5991                 }
5992                 switch fieldNum {
5993                 case 1:
5994                         if wireType != 2 {
5995                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5996                         }
5997                         var stringLen uint64
5998                         for shift := uint(0); ; shift += 7 {
5999                                 if shift >= 64 {
6000                                         return ErrIntOverflowGenerated
6001                                 }
6002                                 if iNdEx >= l {
6003                                         return io.ErrUnexpectedEOF
6004                                 }
6005                                 b := dAtA[iNdEx]
6006                                 iNdEx++
6007                                 stringLen |= (uint64(b) & 0x7F) << shift
6008                                 if b < 0x80 {
6009                                         break
6010                                 }
6011                         }
6012                         intStringLen := int(stringLen)
6013                         if intStringLen < 0 {
6014                                 return ErrInvalidLengthGenerated
6015                         }
6016                         postIndex := iNdEx + intStringLen
6017                         if postIndex > l {
6018                                 return io.ErrUnexpectedEOF
6019                         }
6020                         m.Name = string(dAtA[iNdEx:postIndex])
6021                         iNdEx = postIndex
6022                 case 2:
6023                         if wireType != 2 {
6024                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
6025                         }
6026                         var msglen int
6027                         for shift := uint(0); ; shift += 7 {
6028                                 if shift >= 64 {
6029                                         return ErrIntOverflowGenerated
6030                                 }
6031                                 if iNdEx >= l {
6032                                         return io.ErrUnexpectedEOF
6033                                 }
6034                                 b := dAtA[iNdEx]
6035                                 iNdEx++
6036                                 msglen |= (int(b) & 0x7F) << shift
6037                                 if b < 0x80 {
6038                                         break
6039                                 }
6040                         }
6041                         if msglen < 0 {
6042                                 return ErrInvalidLengthGenerated
6043                         }
6044                         postIndex := iNdEx + msglen
6045                         if postIndex > l {
6046                                 return io.ErrUnexpectedEOF
6047                         }
6048                         if m.UpdatedAnnotations == nil {
6049                                 m.UpdatedAnnotations = make(map[string]string)
6050                         }
6051                         var mapkey string
6052                         var mapvalue string
6053                         for iNdEx < postIndex {
6054                                 entryPreIndex := iNdEx
6055                                 var wire uint64
6056                                 for shift := uint(0); ; shift += 7 {
6057                                         if shift >= 64 {
6058                                                 return ErrIntOverflowGenerated
6059                                         }
6060                                         if iNdEx >= l {
6061                                                 return io.ErrUnexpectedEOF
6062                                         }
6063                                         b := dAtA[iNdEx]
6064                                         iNdEx++
6065                                         wire |= (uint64(b) & 0x7F) << shift
6066                                         if b < 0x80 {
6067                                                 break
6068                                         }
6069                                 }
6070                                 fieldNum := int32(wire >> 3)
6071                                 if fieldNum == 1 {
6072                                         var stringLenmapkey uint64
6073                                         for shift := uint(0); ; shift += 7 {
6074                                                 if shift >= 64 {
6075                                                         return ErrIntOverflowGenerated
6076                                                 }
6077                                                 if iNdEx >= l {
6078                                                         return io.ErrUnexpectedEOF
6079                                                 }
6080                                                 b := dAtA[iNdEx]
6081                                                 iNdEx++
6082                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6083                                                 if b < 0x80 {
6084                                                         break
6085                                                 }
6086                                         }
6087                                         intStringLenmapkey := int(stringLenmapkey)
6088                                         if intStringLenmapkey < 0 {
6089                                                 return ErrInvalidLengthGenerated
6090                                         }
6091                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
6092                                         if postStringIndexmapkey > l {
6093                                                 return io.ErrUnexpectedEOF
6094                                         }
6095                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6096                                         iNdEx = postStringIndexmapkey
6097                                 } else if fieldNum == 2 {
6098                                         var stringLenmapvalue uint64
6099                                         for shift := uint(0); ; shift += 7 {
6100                                                 if shift >= 64 {
6101                                                         return ErrIntOverflowGenerated
6102                                                 }
6103                                                 if iNdEx >= l {
6104                                                         return io.ErrUnexpectedEOF
6105                                                 }
6106                                                 b := dAtA[iNdEx]
6107                                                 iNdEx++
6108                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6109                                                 if b < 0x80 {
6110                                                         break
6111                                                 }
6112                                         }
6113                                         intStringLenmapvalue := int(stringLenmapvalue)
6114                                         if intStringLenmapvalue < 0 {
6115                                                 return ErrInvalidLengthGenerated
6116                                         }
6117                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6118                                         if postStringIndexmapvalue > l {
6119                                                 return io.ErrUnexpectedEOF
6120                                         }
6121                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6122                                         iNdEx = postStringIndexmapvalue
6123                                 } else {
6124                                         iNdEx = entryPreIndex
6125                                         skippy, err := skipGenerated(dAtA[iNdEx:])
6126                                         if err != nil {
6127                                                 return err
6128                                         }
6129                                         if skippy < 0 {
6130                                                 return ErrInvalidLengthGenerated
6131                                         }
6132                                         if (iNdEx + skippy) > postIndex {
6133                                                 return io.ErrUnexpectedEOF
6134                                         }
6135                                         iNdEx += skippy
6136                                 }
6137                         }
6138                         m.UpdatedAnnotations[mapkey] = mapvalue
6139                         iNdEx = postIndex
6140                 case 3:
6141                         if wireType != 2 {
6142                                 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
6143                         }
6144                         var msglen int
6145                         for shift := uint(0); ; shift += 7 {
6146                                 if shift >= 64 {
6147                                         return ErrIntOverflowGenerated
6148                                 }
6149                                 if iNdEx >= l {
6150                                         return io.ErrUnexpectedEOF
6151                                 }
6152                                 b := dAtA[iNdEx]
6153                                 iNdEx++
6154                                 msglen |= (int(b) & 0x7F) << shift
6155                                 if b < 0x80 {
6156                                         break
6157                                 }
6158                         }
6159                         if msglen < 0 {
6160                                 return ErrInvalidLengthGenerated
6161                         }
6162                         postIndex := iNdEx + msglen
6163                         if postIndex > l {
6164                                 return io.ErrUnexpectedEOF
6165                         }
6166                         if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6167                                 return err
6168                         }
6169                         iNdEx = postIndex
6170                 default:
6171                         iNdEx = preIndex
6172                         skippy, err := skipGenerated(dAtA[iNdEx:])
6173                         if err != nil {
6174                                 return err
6175                         }
6176                         if skippy < 0 {
6177                                 return ErrInvalidLengthGenerated
6178                         }
6179                         if (iNdEx + skippy) > l {
6180                                 return io.ErrUnexpectedEOF
6181                         }
6182                         iNdEx += skippy
6183                 }
6184         }
6185
6186         if iNdEx > l {
6187                 return io.ErrUnexpectedEOF
6188         }
6189         return nil
6190 }
6191 func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
6192         l := len(dAtA)
6193         iNdEx := 0
6194         for iNdEx < l {
6195                 preIndex := iNdEx
6196                 var wire uint64
6197                 for shift := uint(0); ; shift += 7 {
6198                         if shift >= 64 {
6199                                 return ErrIntOverflowGenerated
6200                         }
6201                         if iNdEx >= l {
6202                                 return io.ErrUnexpectedEOF
6203                         }
6204                         b := dAtA[iNdEx]
6205                         iNdEx++
6206                         wire |= (uint64(b) & 0x7F) << shift
6207                         if b < 0x80 {
6208                                 break
6209                         }
6210                 }
6211                 fieldNum := int32(wire >> 3)
6212                 wireType := int(wire & 0x7)
6213                 if wireType == 4 {
6214                         return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
6215                 }
6216                 if fieldNum <= 0 {
6217                         return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
6218                 }
6219                 switch fieldNum {
6220                 case 1:
6221                         if wireType != 0 {
6222                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6223                         }
6224                         var v int32
6225                         for shift := uint(0); ; shift += 7 {
6226                                 if shift >= 64 {
6227                                         return ErrIntOverflowGenerated
6228                                 }
6229                                 if iNdEx >= l {
6230                                         return io.ErrUnexpectedEOF
6231                                 }
6232                                 b := dAtA[iNdEx]
6233                                 iNdEx++
6234                                 v |= (int32(b) & 0x7F) << shift
6235                                 if b < 0x80 {
6236                                         break
6237                                 }
6238                         }
6239                         m.Replicas = &v
6240                 case 2:
6241                         if wireType != 2 {
6242                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
6243                         }
6244                         var msglen int
6245                         for shift := uint(0); ; shift += 7 {
6246                                 if shift >= 64 {
6247                                         return ErrIntOverflowGenerated
6248                                 }
6249                                 if iNdEx >= l {
6250                                         return io.ErrUnexpectedEOF
6251                                 }
6252                                 b := dAtA[iNdEx]
6253                                 iNdEx++
6254                                 msglen |= (int(b) & 0x7F) << shift
6255                                 if b < 0x80 {
6256                                         break
6257                                 }
6258                         }
6259                         if msglen < 0 {
6260                                 return ErrInvalidLengthGenerated
6261                         }
6262                         postIndex := iNdEx + msglen
6263                         if postIndex > l {
6264                                 return io.ErrUnexpectedEOF
6265                         }
6266                         if m.Selector == nil {
6267                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
6268                         }
6269                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6270                                 return err
6271                         }
6272                         iNdEx = postIndex
6273                 case 3:
6274                         if wireType != 2 {
6275                                 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
6276                         }
6277                         var msglen int
6278                         for shift := uint(0); ; shift += 7 {
6279                                 if shift >= 64 {
6280                                         return ErrIntOverflowGenerated
6281                                 }
6282                                 if iNdEx >= l {
6283                                         return io.ErrUnexpectedEOF
6284                                 }
6285                                 b := dAtA[iNdEx]
6286                                 iNdEx++
6287                                 msglen |= (int(b) & 0x7F) << shift
6288                                 if b < 0x80 {
6289                                         break
6290                                 }
6291                         }
6292                         if msglen < 0 {
6293                                 return ErrInvalidLengthGenerated
6294                         }
6295                         postIndex := iNdEx + msglen
6296                         if postIndex > l {
6297                                 return io.ErrUnexpectedEOF
6298                         }
6299                         if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6300                                 return err
6301                         }
6302                         iNdEx = postIndex
6303                 case 4:
6304                         if wireType != 2 {
6305                                 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
6306                         }
6307                         var msglen int
6308                         for shift := uint(0); ; shift += 7 {
6309                                 if shift >= 64 {
6310                                         return ErrIntOverflowGenerated
6311                                 }
6312                                 if iNdEx >= l {
6313                                         return io.ErrUnexpectedEOF
6314                                 }
6315                                 b := dAtA[iNdEx]
6316                                 iNdEx++
6317                                 msglen |= (int(b) & 0x7F) << shift
6318                                 if b < 0x80 {
6319                                         break
6320                                 }
6321                         }
6322                         if msglen < 0 {
6323                                 return ErrInvalidLengthGenerated
6324                         }
6325                         postIndex := iNdEx + msglen
6326                         if postIndex > l {
6327                                 return io.ErrUnexpectedEOF
6328                         }
6329                         if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6330                                 return err
6331                         }
6332                         iNdEx = postIndex
6333                 case 5:
6334                         if wireType != 0 {
6335                                 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
6336                         }
6337                         m.MinReadySeconds = 0
6338                         for shift := uint(0); ; shift += 7 {
6339                                 if shift >= 64 {
6340                                         return ErrIntOverflowGenerated
6341                                 }
6342                                 if iNdEx >= l {
6343                                         return io.ErrUnexpectedEOF
6344                                 }
6345                                 b := dAtA[iNdEx]
6346                                 iNdEx++
6347                                 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
6348                                 if b < 0x80 {
6349                                         break
6350                                 }
6351                         }
6352                 case 6:
6353                         if wireType != 0 {
6354                                 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
6355                         }
6356                         var v int32
6357                         for shift := uint(0); ; shift += 7 {
6358                                 if shift >= 64 {
6359                                         return ErrIntOverflowGenerated
6360                                 }
6361                                 if iNdEx >= l {
6362                                         return io.ErrUnexpectedEOF
6363                                 }
6364                                 b := dAtA[iNdEx]
6365                                 iNdEx++
6366                                 v |= (int32(b) & 0x7F) << shift
6367                                 if b < 0x80 {
6368                                         break
6369                                 }
6370                         }
6371                         m.RevisionHistoryLimit = &v
6372                 case 7:
6373                         if wireType != 0 {
6374                                 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
6375                         }
6376                         var v int
6377                         for shift := uint(0); ; shift += 7 {
6378                                 if shift >= 64 {
6379                                         return ErrIntOverflowGenerated
6380                                 }
6381                                 if iNdEx >= l {
6382                                         return io.ErrUnexpectedEOF
6383                                 }
6384                                 b := dAtA[iNdEx]
6385                                 iNdEx++
6386                                 v |= (int(b) & 0x7F) << shift
6387                                 if b < 0x80 {
6388                                         break
6389                                 }
6390                         }
6391                         m.Paused = bool(v != 0)
6392                 case 8:
6393                         if wireType != 2 {
6394                                 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
6395                         }
6396                         var msglen int
6397                         for shift := uint(0); ; shift += 7 {
6398                                 if shift >= 64 {
6399                                         return ErrIntOverflowGenerated
6400                                 }
6401                                 if iNdEx >= l {
6402                                         return io.ErrUnexpectedEOF
6403                                 }
6404                                 b := dAtA[iNdEx]
6405                                 iNdEx++
6406                                 msglen |= (int(b) & 0x7F) << shift
6407                                 if b < 0x80 {
6408                                         break
6409                                 }
6410                         }
6411                         if msglen < 0 {
6412                                 return ErrInvalidLengthGenerated
6413                         }
6414                         postIndex := iNdEx + msglen
6415                         if postIndex > l {
6416                                 return io.ErrUnexpectedEOF
6417                         }
6418                         if m.RollbackTo == nil {
6419                                 m.RollbackTo = &RollbackConfig{}
6420                         }
6421                         if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6422                                 return err
6423                         }
6424                         iNdEx = postIndex
6425                 case 9:
6426                         if wireType != 0 {
6427                                 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
6428                         }
6429                         var v int32
6430                         for shift := uint(0); ; shift += 7 {
6431                                 if shift >= 64 {
6432                                         return ErrIntOverflowGenerated
6433                                 }
6434                                 if iNdEx >= l {
6435                                         return io.ErrUnexpectedEOF
6436                                 }
6437                                 b := dAtA[iNdEx]
6438                                 iNdEx++
6439                                 v |= (int32(b) & 0x7F) << shift
6440                                 if b < 0x80 {
6441                                         break
6442                                 }
6443                         }
6444                         m.ProgressDeadlineSeconds = &v
6445                 default:
6446                         iNdEx = preIndex
6447                         skippy, err := skipGenerated(dAtA[iNdEx:])
6448                         if err != nil {
6449                                 return err
6450                         }
6451                         if skippy < 0 {
6452                                 return ErrInvalidLengthGenerated
6453                         }
6454                         if (iNdEx + skippy) > l {
6455                                 return io.ErrUnexpectedEOF
6456                         }
6457                         iNdEx += skippy
6458                 }
6459         }
6460
6461         if iNdEx > l {
6462                 return io.ErrUnexpectedEOF
6463         }
6464         return nil
6465 }
6466 func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
6467         l := len(dAtA)
6468         iNdEx := 0
6469         for iNdEx < l {
6470                 preIndex := iNdEx
6471                 var wire uint64
6472                 for shift := uint(0); ; shift += 7 {
6473                         if shift >= 64 {
6474                                 return ErrIntOverflowGenerated
6475                         }
6476                         if iNdEx >= l {
6477                                 return io.ErrUnexpectedEOF
6478                         }
6479                         b := dAtA[iNdEx]
6480                         iNdEx++
6481                         wire |= (uint64(b) & 0x7F) << shift
6482                         if b < 0x80 {
6483                                 break
6484                         }
6485                 }
6486                 fieldNum := int32(wire >> 3)
6487                 wireType := int(wire & 0x7)
6488                 if wireType == 4 {
6489                         return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
6490                 }
6491                 if fieldNum <= 0 {
6492                         return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6493                 }
6494                 switch fieldNum {
6495                 case 1:
6496                         if wireType != 0 {
6497                                 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
6498                         }
6499                         m.ObservedGeneration = 0
6500                         for shift := uint(0); ; shift += 7 {
6501                                 if shift >= 64 {
6502                                         return ErrIntOverflowGenerated
6503                                 }
6504                                 if iNdEx >= l {
6505                                         return io.ErrUnexpectedEOF
6506                                 }
6507                                 b := dAtA[iNdEx]
6508                                 iNdEx++
6509                                 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
6510                                 if b < 0x80 {
6511                                         break
6512                                 }
6513                         }
6514                 case 2:
6515                         if wireType != 0 {
6516                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6517                         }
6518                         m.Replicas = 0
6519                         for shift := uint(0); ; shift += 7 {
6520                                 if shift >= 64 {
6521                                         return ErrIntOverflowGenerated
6522                                 }
6523                                 if iNdEx >= l {
6524                                         return io.ErrUnexpectedEOF
6525                                 }
6526                                 b := dAtA[iNdEx]
6527                                 iNdEx++
6528                                 m.Replicas |= (int32(b) & 0x7F) << shift
6529                                 if b < 0x80 {
6530                                         break
6531                                 }
6532                         }
6533                 case 3:
6534                         if wireType != 0 {
6535                                 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
6536                         }
6537                         m.UpdatedReplicas = 0
6538                         for shift := uint(0); ; shift += 7 {
6539                                 if shift >= 64 {
6540                                         return ErrIntOverflowGenerated
6541                                 }
6542                                 if iNdEx >= l {
6543                                         return io.ErrUnexpectedEOF
6544                                 }
6545                                 b := dAtA[iNdEx]
6546                                 iNdEx++
6547                                 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
6548                                 if b < 0x80 {
6549                                         break
6550                                 }
6551                         }
6552                 case 4:
6553                         if wireType != 0 {
6554                                 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
6555                         }
6556                         m.AvailableReplicas = 0
6557                         for shift := uint(0); ; shift += 7 {
6558                                 if shift >= 64 {
6559                                         return ErrIntOverflowGenerated
6560                                 }
6561                                 if iNdEx >= l {
6562                                         return io.ErrUnexpectedEOF
6563                                 }
6564                                 b := dAtA[iNdEx]
6565                                 iNdEx++
6566                                 m.AvailableReplicas |= (int32(b) & 0x7F) << shift
6567                                 if b < 0x80 {
6568                                         break
6569                                 }
6570                         }
6571                 case 5:
6572                         if wireType != 0 {
6573                                 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
6574                         }
6575                         m.UnavailableReplicas = 0
6576                         for shift := uint(0); ; shift += 7 {
6577                                 if shift >= 64 {
6578                                         return ErrIntOverflowGenerated
6579                                 }
6580                                 if iNdEx >= l {
6581                                         return io.ErrUnexpectedEOF
6582                                 }
6583                                 b := dAtA[iNdEx]
6584                                 iNdEx++
6585                                 m.UnavailableReplicas |= (int32(b) & 0x7F) << shift
6586                                 if b < 0x80 {
6587                                         break
6588                                 }
6589                         }
6590                 case 6:
6591                         if wireType != 2 {
6592                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
6593                         }
6594                         var msglen int
6595                         for shift := uint(0); ; shift += 7 {
6596                                 if shift >= 64 {
6597                                         return ErrIntOverflowGenerated
6598                                 }
6599                                 if iNdEx >= l {
6600                                         return io.ErrUnexpectedEOF
6601                                 }
6602                                 b := dAtA[iNdEx]
6603                                 iNdEx++
6604                                 msglen |= (int(b) & 0x7F) << shift
6605                                 if b < 0x80 {
6606                                         break
6607                                 }
6608                         }
6609                         if msglen < 0 {
6610                                 return ErrInvalidLengthGenerated
6611                         }
6612                         postIndex := iNdEx + msglen
6613                         if postIndex > l {
6614                                 return io.ErrUnexpectedEOF
6615                         }
6616                         m.Conditions = append(m.Conditions, DeploymentCondition{})
6617                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6618                                 return err
6619                         }
6620                         iNdEx = postIndex
6621                 case 7:
6622                         if wireType != 0 {
6623                                 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
6624                         }
6625                         m.ReadyReplicas = 0
6626                         for shift := uint(0); ; shift += 7 {
6627                                 if shift >= 64 {
6628                                         return ErrIntOverflowGenerated
6629                                 }
6630                                 if iNdEx >= l {
6631                                         return io.ErrUnexpectedEOF
6632                                 }
6633                                 b := dAtA[iNdEx]
6634                                 iNdEx++
6635                                 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
6636                                 if b < 0x80 {
6637                                         break
6638                                 }
6639                         }
6640                 case 8:
6641                         if wireType != 0 {
6642                                 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
6643                         }
6644                         var v int32
6645                         for shift := uint(0); ; shift += 7 {
6646                                 if shift >= 64 {
6647                                         return ErrIntOverflowGenerated
6648                                 }
6649                                 if iNdEx >= l {
6650                                         return io.ErrUnexpectedEOF
6651                                 }
6652                                 b := dAtA[iNdEx]
6653                                 iNdEx++
6654                                 v |= (int32(b) & 0x7F) << shift
6655                                 if b < 0x80 {
6656                                         break
6657                                 }
6658                         }
6659                         m.CollisionCount = &v
6660                 default:
6661                         iNdEx = preIndex
6662                         skippy, err := skipGenerated(dAtA[iNdEx:])
6663                         if err != nil {
6664                                 return err
6665                         }
6666                         if skippy < 0 {
6667                                 return ErrInvalidLengthGenerated
6668                         }
6669                         if (iNdEx + skippy) > l {
6670                                 return io.ErrUnexpectedEOF
6671                         }
6672                         iNdEx += skippy
6673                 }
6674         }
6675
6676         if iNdEx > l {
6677                 return io.ErrUnexpectedEOF
6678         }
6679         return nil
6680 }
6681 func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
6682         l := len(dAtA)
6683         iNdEx := 0
6684         for iNdEx < l {
6685                 preIndex := iNdEx
6686                 var wire uint64
6687                 for shift := uint(0); ; shift += 7 {
6688                         if shift >= 64 {
6689                                 return ErrIntOverflowGenerated
6690                         }
6691                         if iNdEx >= l {
6692                                 return io.ErrUnexpectedEOF
6693                         }
6694                         b := dAtA[iNdEx]
6695                         iNdEx++
6696                         wire |= (uint64(b) & 0x7F) << shift
6697                         if b < 0x80 {
6698                                 break
6699                         }
6700                 }
6701                 fieldNum := int32(wire >> 3)
6702                 wireType := int(wire & 0x7)
6703                 if wireType == 4 {
6704                         return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
6705                 }
6706                 if fieldNum <= 0 {
6707                         return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
6708                 }
6709                 switch fieldNum {
6710                 case 1:
6711                         if wireType != 2 {
6712                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
6713                         }
6714                         var stringLen uint64
6715                         for shift := uint(0); ; shift += 7 {
6716                                 if shift >= 64 {
6717                                         return ErrIntOverflowGenerated
6718                                 }
6719                                 if iNdEx >= l {
6720                                         return io.ErrUnexpectedEOF
6721                                 }
6722                                 b := dAtA[iNdEx]
6723                                 iNdEx++
6724                                 stringLen |= (uint64(b) & 0x7F) << shift
6725                                 if b < 0x80 {
6726                                         break
6727                                 }
6728                         }
6729                         intStringLen := int(stringLen)
6730                         if intStringLen < 0 {
6731                                 return ErrInvalidLengthGenerated
6732                         }
6733                         postIndex := iNdEx + intStringLen
6734                         if postIndex > l {
6735                                 return io.ErrUnexpectedEOF
6736                         }
6737                         m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
6738                         iNdEx = postIndex
6739                 case 2:
6740                         if wireType != 2 {
6741                                 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
6742                         }
6743                         var msglen int
6744                         for shift := uint(0); ; shift += 7 {
6745                                 if shift >= 64 {
6746                                         return ErrIntOverflowGenerated
6747                                 }
6748                                 if iNdEx >= l {
6749                                         return io.ErrUnexpectedEOF
6750                                 }
6751                                 b := dAtA[iNdEx]
6752                                 iNdEx++
6753                                 msglen |= (int(b) & 0x7F) << shift
6754                                 if b < 0x80 {
6755                                         break
6756                                 }
6757                         }
6758                         if msglen < 0 {
6759                                 return ErrInvalidLengthGenerated
6760                         }
6761                         postIndex := iNdEx + msglen
6762                         if postIndex > l {
6763                                 return io.ErrUnexpectedEOF
6764                         }
6765                         if m.RollingUpdate == nil {
6766                                 m.RollingUpdate = &RollingUpdateDeployment{}
6767                         }
6768                         if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6769                                 return err
6770                         }
6771                         iNdEx = postIndex
6772                 default:
6773                         iNdEx = preIndex
6774                         skippy, err := skipGenerated(dAtA[iNdEx:])
6775                         if err != nil {
6776                                 return err
6777                         }
6778                         if skippy < 0 {
6779                                 return ErrInvalidLengthGenerated
6780                         }
6781                         if (iNdEx + skippy) > l {
6782                                 return io.ErrUnexpectedEOF
6783                         }
6784                         iNdEx += skippy
6785                 }
6786         }
6787
6788         if iNdEx > l {
6789                 return io.ErrUnexpectedEOF
6790         }
6791         return nil
6792 }
6793 func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error {
6794         l := len(dAtA)
6795         iNdEx := 0
6796         for iNdEx < l {
6797                 preIndex := iNdEx
6798                 var wire uint64
6799                 for shift := uint(0); ; shift += 7 {
6800                         if shift >= 64 {
6801                                 return ErrIntOverflowGenerated
6802                         }
6803                         if iNdEx >= l {
6804                                 return io.ErrUnexpectedEOF
6805                         }
6806                         b := dAtA[iNdEx]
6807                         iNdEx++
6808                         wire |= (uint64(b) & 0x7F) << shift
6809                         if b < 0x80 {
6810                                 break
6811                         }
6812                 }
6813                 fieldNum := int32(wire >> 3)
6814                 wireType := int(wire & 0x7)
6815                 if wireType == 4 {
6816                         return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group")
6817                 }
6818                 if fieldNum <= 0 {
6819                         return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
6820                 }
6821                 switch fieldNum {
6822                 case 1:
6823                         if wireType != 2 {
6824                                 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
6825                         }
6826                         var stringLen uint64
6827                         for shift := uint(0); ; shift += 7 {
6828                                 if shift >= 64 {
6829                                         return ErrIntOverflowGenerated
6830                                 }
6831                                 if iNdEx >= l {
6832                                         return io.ErrUnexpectedEOF
6833                                 }
6834                                 b := dAtA[iNdEx]
6835                                 iNdEx++
6836                                 stringLen |= (uint64(b) & 0x7F) << shift
6837                                 if b < 0x80 {
6838                                         break
6839                                 }
6840                         }
6841                         intStringLen := int(stringLen)
6842                         if intStringLen < 0 {
6843                                 return ErrInvalidLengthGenerated
6844                         }
6845                         postIndex := iNdEx + intStringLen
6846                         if postIndex > l {
6847                                 return io.ErrUnexpectedEOF
6848                         }
6849                         m.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex])
6850                         iNdEx = postIndex
6851                 case 2:
6852                         if wireType != 2 {
6853                                 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
6854                         }
6855                         var msglen int
6856                         for shift := uint(0); ; shift += 7 {
6857                                 if shift >= 64 {
6858                                         return ErrIntOverflowGenerated
6859                                 }
6860                                 if iNdEx >= l {
6861                                         return io.ErrUnexpectedEOF
6862                                 }
6863                                 b := dAtA[iNdEx]
6864                                 iNdEx++
6865                                 msglen |= (int(b) & 0x7F) << shift
6866                                 if b < 0x80 {
6867                                         break
6868                                 }
6869                         }
6870                         if msglen < 0 {
6871                                 return ErrInvalidLengthGenerated
6872                         }
6873                         postIndex := iNdEx + msglen
6874                         if postIndex > l {
6875                                 return io.ErrUnexpectedEOF
6876                         }
6877                         m.Ranges = append(m.Ranges, IDRange{})
6878                         if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6879                                 return err
6880                         }
6881                         iNdEx = postIndex
6882                 default:
6883                         iNdEx = preIndex
6884                         skippy, err := skipGenerated(dAtA[iNdEx:])
6885                         if err != nil {
6886                                 return err
6887                         }
6888                         if skippy < 0 {
6889                                 return ErrInvalidLengthGenerated
6890                         }
6891                         if (iNdEx + skippy) > l {
6892                                 return io.ErrUnexpectedEOF
6893                         }
6894                         iNdEx += skippy
6895                 }
6896         }
6897
6898         if iNdEx > l {
6899                 return io.ErrUnexpectedEOF
6900         }
6901         return nil
6902 }
6903 func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error {
6904         l := len(dAtA)
6905         iNdEx := 0
6906         for iNdEx < l {
6907                 preIndex := iNdEx
6908                 var wire uint64
6909                 for shift := uint(0); ; shift += 7 {
6910                         if shift >= 64 {
6911                                 return ErrIntOverflowGenerated
6912                         }
6913                         if iNdEx >= l {
6914                                 return io.ErrUnexpectedEOF
6915                         }
6916                         b := dAtA[iNdEx]
6917                         iNdEx++
6918                         wire |= (uint64(b) & 0x7F) << shift
6919                         if b < 0x80 {
6920                                 break
6921                         }
6922                 }
6923                 fieldNum := int32(wire >> 3)
6924                 wireType := int(wire & 0x7)
6925                 if wireType == 4 {
6926                         return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group")
6927                 }
6928                 if fieldNum <= 0 {
6929                         return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire)
6930                 }
6931                 switch fieldNum {
6932                 case 1:
6933                         if wireType != 2 {
6934                                 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
6935                         }
6936                         var stringLen uint64
6937                         for shift := uint(0); ; shift += 7 {
6938                                 if shift >= 64 {
6939                                         return ErrIntOverflowGenerated
6940                                 }
6941                                 if iNdEx >= l {
6942                                         return io.ErrUnexpectedEOF
6943                                 }
6944                                 b := dAtA[iNdEx]
6945                                 iNdEx++
6946                                 stringLen |= (uint64(b) & 0x7F) << shift
6947                                 if b < 0x80 {
6948                                         break
6949                                 }
6950                         }
6951                         intStringLen := int(stringLen)
6952                         if intStringLen < 0 {
6953                                 return ErrInvalidLengthGenerated
6954                         }
6955                         postIndex := iNdEx + intStringLen
6956                         if postIndex > l {
6957                                 return io.ErrUnexpectedEOF
6958                         }
6959                         m.Path = string(dAtA[iNdEx:postIndex])
6960                         iNdEx = postIndex
6961                 case 2:
6962                         if wireType != 2 {
6963                                 return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
6964                         }
6965                         var msglen int
6966                         for shift := uint(0); ; shift += 7 {
6967                                 if shift >= 64 {
6968                                         return ErrIntOverflowGenerated
6969                                 }
6970                                 if iNdEx >= l {
6971                                         return io.ErrUnexpectedEOF
6972                                 }
6973                                 b := dAtA[iNdEx]
6974                                 iNdEx++
6975                                 msglen |= (int(b) & 0x7F) << shift
6976                                 if b < 0x80 {
6977                                         break
6978                                 }
6979                         }
6980                         if msglen < 0 {
6981                                 return ErrInvalidLengthGenerated
6982                         }
6983                         postIndex := iNdEx + msglen
6984                         if postIndex > l {
6985                                 return io.ErrUnexpectedEOF
6986                         }
6987                         if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6988                                 return err
6989                         }
6990                         iNdEx = postIndex
6991                 default:
6992                         iNdEx = preIndex
6993                         skippy, err := skipGenerated(dAtA[iNdEx:])
6994                         if err != nil {
6995                                 return err
6996                         }
6997                         if skippy < 0 {
6998                                 return ErrInvalidLengthGenerated
6999                         }
7000                         if (iNdEx + skippy) > l {
7001                                 return io.ErrUnexpectedEOF
7002                         }
7003                         iNdEx += skippy
7004                 }
7005         }
7006
7007         if iNdEx > l {
7008                 return io.ErrUnexpectedEOF
7009         }
7010         return nil
7011 }
7012 func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error {
7013         l := len(dAtA)
7014         iNdEx := 0
7015         for iNdEx < l {
7016                 preIndex := iNdEx
7017                 var wire uint64
7018                 for shift := uint(0); ; shift += 7 {
7019                         if shift >= 64 {
7020                                 return ErrIntOverflowGenerated
7021                         }
7022                         if iNdEx >= l {
7023                                 return io.ErrUnexpectedEOF
7024                         }
7025                         b := dAtA[iNdEx]
7026                         iNdEx++
7027                         wire |= (uint64(b) & 0x7F) << shift
7028                         if b < 0x80 {
7029                                 break
7030                         }
7031                 }
7032                 fieldNum := int32(wire >> 3)
7033                 wireType := int(wire & 0x7)
7034                 if wireType == 4 {
7035                         return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group")
7036                 }
7037                 if fieldNum <= 0 {
7038                         return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
7039                 }
7040                 switch fieldNum {
7041                 case 1:
7042                         if wireType != 2 {
7043                                 return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
7044                         }
7045                         var msglen int
7046                         for shift := uint(0); ; shift += 7 {
7047                                 if shift >= 64 {
7048                                         return ErrIntOverflowGenerated
7049                                 }
7050                                 if iNdEx >= l {
7051                                         return io.ErrUnexpectedEOF
7052                                 }
7053                                 b := dAtA[iNdEx]
7054                                 iNdEx++
7055                                 msglen |= (int(b) & 0x7F) << shift
7056                                 if b < 0x80 {
7057                                         break
7058                                 }
7059                         }
7060                         if msglen < 0 {
7061                                 return ErrInvalidLengthGenerated
7062                         }
7063                         postIndex := iNdEx + msglen
7064                         if postIndex > l {
7065                                 return io.ErrUnexpectedEOF
7066                         }
7067                         m.Paths = append(m.Paths, HTTPIngressPath{})
7068                         if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7069                                 return err
7070                         }
7071                         iNdEx = postIndex
7072                 default:
7073                         iNdEx = preIndex
7074                         skippy, err := skipGenerated(dAtA[iNdEx:])
7075                         if err != nil {
7076                                 return err
7077                         }
7078                         if skippy < 0 {
7079                                 return ErrInvalidLengthGenerated
7080                         }
7081                         if (iNdEx + skippy) > l {
7082                                 return io.ErrUnexpectedEOF
7083                         }
7084                         iNdEx += skippy
7085                 }
7086         }
7087
7088         if iNdEx > l {
7089                 return io.ErrUnexpectedEOF
7090         }
7091         return nil
7092 }
7093 func (m *HostPortRange) Unmarshal(dAtA []byte) error {
7094         l := len(dAtA)
7095         iNdEx := 0
7096         for iNdEx < l {
7097                 preIndex := iNdEx
7098                 var wire uint64
7099                 for shift := uint(0); ; shift += 7 {
7100                         if shift >= 64 {
7101                                 return ErrIntOverflowGenerated
7102                         }
7103                         if iNdEx >= l {
7104                                 return io.ErrUnexpectedEOF
7105                         }
7106                         b := dAtA[iNdEx]
7107                         iNdEx++
7108                         wire |= (uint64(b) & 0x7F) << shift
7109                         if b < 0x80 {
7110                                 break
7111                         }
7112                 }
7113                 fieldNum := int32(wire >> 3)
7114                 wireType := int(wire & 0x7)
7115                 if wireType == 4 {
7116                         return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group")
7117                 }
7118                 if fieldNum <= 0 {
7119                         return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire)
7120                 }
7121                 switch fieldNum {
7122                 case 1:
7123                         if wireType != 0 {
7124                                 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
7125                         }
7126                         m.Min = 0
7127                         for shift := uint(0); ; shift += 7 {
7128                                 if shift >= 64 {
7129                                         return ErrIntOverflowGenerated
7130                                 }
7131                                 if iNdEx >= l {
7132                                         return io.ErrUnexpectedEOF
7133                                 }
7134                                 b := dAtA[iNdEx]
7135                                 iNdEx++
7136                                 m.Min |= (int32(b) & 0x7F) << shift
7137                                 if b < 0x80 {
7138                                         break
7139                                 }
7140                         }
7141                 case 2:
7142                         if wireType != 0 {
7143                                 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
7144                         }
7145                         m.Max = 0
7146                         for shift := uint(0); ; shift += 7 {
7147                                 if shift >= 64 {
7148                                         return ErrIntOverflowGenerated
7149                                 }
7150                                 if iNdEx >= l {
7151                                         return io.ErrUnexpectedEOF
7152                                 }
7153                                 b := dAtA[iNdEx]
7154                                 iNdEx++
7155                                 m.Max |= (int32(b) & 0x7F) << shift
7156                                 if b < 0x80 {
7157                                         break
7158                                 }
7159                         }
7160                 default:
7161                         iNdEx = preIndex
7162                         skippy, err := skipGenerated(dAtA[iNdEx:])
7163                         if err != nil {
7164                                 return err
7165                         }
7166                         if skippy < 0 {
7167                                 return ErrInvalidLengthGenerated
7168                         }
7169                         if (iNdEx + skippy) > l {
7170                                 return io.ErrUnexpectedEOF
7171                         }
7172                         iNdEx += skippy
7173                 }
7174         }
7175
7176         if iNdEx > l {
7177                 return io.ErrUnexpectedEOF
7178         }
7179         return nil
7180 }
7181 func (m *IDRange) Unmarshal(dAtA []byte) error {
7182         l := len(dAtA)
7183         iNdEx := 0
7184         for iNdEx < l {
7185                 preIndex := iNdEx
7186                 var wire uint64
7187                 for shift := uint(0); ; shift += 7 {
7188                         if shift >= 64 {
7189                                 return ErrIntOverflowGenerated
7190                         }
7191                         if iNdEx >= l {
7192                                 return io.ErrUnexpectedEOF
7193                         }
7194                         b := dAtA[iNdEx]
7195                         iNdEx++
7196                         wire |= (uint64(b) & 0x7F) << shift
7197                         if b < 0x80 {
7198                                 break
7199                         }
7200                 }
7201                 fieldNum := int32(wire >> 3)
7202                 wireType := int(wire & 0x7)
7203                 if wireType == 4 {
7204                         return fmt.Errorf("proto: IDRange: wiretype end group for non-group")
7205                 }
7206                 if fieldNum <= 0 {
7207                         return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire)
7208                 }
7209                 switch fieldNum {
7210                 case 1:
7211                         if wireType != 0 {
7212                                 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
7213                         }
7214                         m.Min = 0
7215                         for shift := uint(0); ; shift += 7 {
7216                                 if shift >= 64 {
7217                                         return ErrIntOverflowGenerated
7218                                 }
7219                                 if iNdEx >= l {
7220                                         return io.ErrUnexpectedEOF
7221                                 }
7222                                 b := dAtA[iNdEx]
7223                                 iNdEx++
7224                                 m.Min |= (int64(b) & 0x7F) << shift
7225                                 if b < 0x80 {
7226                                         break
7227                                 }
7228                         }
7229                 case 2:
7230                         if wireType != 0 {
7231                                 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
7232                         }
7233                         m.Max = 0
7234                         for shift := uint(0); ; shift += 7 {
7235                                 if shift >= 64 {
7236                                         return ErrIntOverflowGenerated
7237                                 }
7238                                 if iNdEx >= l {
7239                                         return io.ErrUnexpectedEOF
7240                                 }
7241                                 b := dAtA[iNdEx]
7242                                 iNdEx++
7243                                 m.Max |= (int64(b) & 0x7F) << shift
7244                                 if b < 0x80 {
7245                                         break
7246                                 }
7247                         }
7248                 default:
7249                         iNdEx = preIndex
7250                         skippy, err := skipGenerated(dAtA[iNdEx:])
7251                         if err != nil {
7252                                 return err
7253                         }
7254                         if skippy < 0 {
7255                                 return ErrInvalidLengthGenerated
7256                         }
7257                         if (iNdEx + skippy) > l {
7258                                 return io.ErrUnexpectedEOF
7259                         }
7260                         iNdEx += skippy
7261                 }
7262         }
7263
7264         if iNdEx > l {
7265                 return io.ErrUnexpectedEOF
7266         }
7267         return nil
7268 }
7269 func (m *IPBlock) Unmarshal(dAtA []byte) error {
7270         l := len(dAtA)
7271         iNdEx := 0
7272         for iNdEx < l {
7273                 preIndex := iNdEx
7274                 var wire uint64
7275                 for shift := uint(0); ; shift += 7 {
7276                         if shift >= 64 {
7277                                 return ErrIntOverflowGenerated
7278                         }
7279                         if iNdEx >= l {
7280                                 return io.ErrUnexpectedEOF
7281                         }
7282                         b := dAtA[iNdEx]
7283                         iNdEx++
7284                         wire |= (uint64(b) & 0x7F) << shift
7285                         if b < 0x80 {
7286                                 break
7287                         }
7288                 }
7289                 fieldNum := int32(wire >> 3)
7290                 wireType := int(wire & 0x7)
7291                 if wireType == 4 {
7292                         return fmt.Errorf("proto: IPBlock: wiretype end group for non-group")
7293                 }
7294                 if fieldNum <= 0 {
7295                         return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire)
7296                 }
7297                 switch fieldNum {
7298                 case 1:
7299                         if wireType != 2 {
7300                                 return fmt.Errorf("proto: wrong wireType = %d for field CIDR", wireType)
7301                         }
7302                         var stringLen uint64
7303                         for shift := uint(0); ; shift += 7 {
7304                                 if shift >= 64 {
7305                                         return ErrIntOverflowGenerated
7306                                 }
7307                                 if iNdEx >= l {
7308                                         return io.ErrUnexpectedEOF
7309                                 }
7310                                 b := dAtA[iNdEx]
7311                                 iNdEx++
7312                                 stringLen |= (uint64(b) & 0x7F) << shift
7313                                 if b < 0x80 {
7314                                         break
7315                                 }
7316                         }
7317                         intStringLen := int(stringLen)
7318                         if intStringLen < 0 {
7319                                 return ErrInvalidLengthGenerated
7320                         }
7321                         postIndex := iNdEx + intStringLen
7322                         if postIndex > l {
7323                                 return io.ErrUnexpectedEOF
7324                         }
7325                         m.CIDR = string(dAtA[iNdEx:postIndex])
7326                         iNdEx = postIndex
7327                 case 2:
7328                         if wireType != 2 {
7329                                 return fmt.Errorf("proto: wrong wireType = %d for field Except", wireType)
7330                         }
7331                         var stringLen uint64
7332                         for shift := uint(0); ; shift += 7 {
7333                                 if shift >= 64 {
7334                                         return ErrIntOverflowGenerated
7335                                 }
7336                                 if iNdEx >= l {
7337                                         return io.ErrUnexpectedEOF
7338                                 }
7339                                 b := dAtA[iNdEx]
7340                                 iNdEx++
7341                                 stringLen |= (uint64(b) & 0x7F) << shift
7342                                 if b < 0x80 {
7343                                         break
7344                                 }
7345                         }
7346                         intStringLen := int(stringLen)
7347                         if intStringLen < 0 {
7348                                 return ErrInvalidLengthGenerated
7349                         }
7350                         postIndex := iNdEx + intStringLen
7351                         if postIndex > l {
7352                                 return io.ErrUnexpectedEOF
7353                         }
7354                         m.Except = append(m.Except, string(dAtA[iNdEx:postIndex]))
7355                         iNdEx = postIndex
7356                 default:
7357                         iNdEx = preIndex
7358                         skippy, err := skipGenerated(dAtA[iNdEx:])
7359                         if err != nil {
7360                                 return err
7361                         }
7362                         if skippy < 0 {
7363                                 return ErrInvalidLengthGenerated
7364                         }
7365                         if (iNdEx + skippy) > l {
7366                                 return io.ErrUnexpectedEOF
7367                         }
7368                         iNdEx += skippy
7369                 }
7370         }
7371
7372         if iNdEx > l {
7373                 return io.ErrUnexpectedEOF
7374         }
7375         return nil
7376 }
7377 func (m *Ingress) Unmarshal(dAtA []byte) error {
7378         l := len(dAtA)
7379         iNdEx := 0
7380         for iNdEx < l {
7381                 preIndex := iNdEx
7382                 var wire uint64
7383                 for shift := uint(0); ; shift += 7 {
7384                         if shift >= 64 {
7385                                 return ErrIntOverflowGenerated
7386                         }
7387                         if iNdEx >= l {
7388                                 return io.ErrUnexpectedEOF
7389                         }
7390                         b := dAtA[iNdEx]
7391                         iNdEx++
7392                         wire |= (uint64(b) & 0x7F) << shift
7393                         if b < 0x80 {
7394                                 break
7395                         }
7396                 }
7397                 fieldNum := int32(wire >> 3)
7398                 wireType := int(wire & 0x7)
7399                 if wireType == 4 {
7400                         return fmt.Errorf("proto: Ingress: wiretype end group for non-group")
7401                 }
7402                 if fieldNum <= 0 {
7403                         return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
7404                 }
7405                 switch fieldNum {
7406                 case 1:
7407                         if wireType != 2 {
7408                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
7409                         }
7410                         var msglen int
7411                         for shift := uint(0); ; shift += 7 {
7412                                 if shift >= 64 {
7413                                         return ErrIntOverflowGenerated
7414                                 }
7415                                 if iNdEx >= l {
7416                                         return io.ErrUnexpectedEOF
7417                                 }
7418                                 b := dAtA[iNdEx]
7419                                 iNdEx++
7420                                 msglen |= (int(b) & 0x7F) << shift
7421                                 if b < 0x80 {
7422                                         break
7423                                 }
7424                         }
7425                         if msglen < 0 {
7426                                 return ErrInvalidLengthGenerated
7427                         }
7428                         postIndex := iNdEx + msglen
7429                         if postIndex > l {
7430                                 return io.ErrUnexpectedEOF
7431                         }
7432                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7433                                 return err
7434                         }
7435                         iNdEx = postIndex
7436                 case 2:
7437                         if wireType != 2 {
7438                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
7439                         }
7440                         var msglen int
7441                         for shift := uint(0); ; shift += 7 {
7442                                 if shift >= 64 {
7443                                         return ErrIntOverflowGenerated
7444                                 }
7445                                 if iNdEx >= l {
7446                                         return io.ErrUnexpectedEOF
7447                                 }
7448                                 b := dAtA[iNdEx]
7449                                 iNdEx++
7450                                 msglen |= (int(b) & 0x7F) << shift
7451                                 if b < 0x80 {
7452                                         break
7453                                 }
7454                         }
7455                         if msglen < 0 {
7456                                 return ErrInvalidLengthGenerated
7457                         }
7458                         postIndex := iNdEx + msglen
7459                         if postIndex > l {
7460                                 return io.ErrUnexpectedEOF
7461                         }
7462                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7463                                 return err
7464                         }
7465                         iNdEx = postIndex
7466                 case 3:
7467                         if wireType != 2 {
7468                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7469                         }
7470                         var msglen int
7471                         for shift := uint(0); ; shift += 7 {
7472                                 if shift >= 64 {
7473                                         return ErrIntOverflowGenerated
7474                                 }
7475                                 if iNdEx >= l {
7476                                         return io.ErrUnexpectedEOF
7477                                 }
7478                                 b := dAtA[iNdEx]
7479                                 iNdEx++
7480                                 msglen |= (int(b) & 0x7F) << shift
7481                                 if b < 0x80 {
7482                                         break
7483                                 }
7484                         }
7485                         if msglen < 0 {
7486                                 return ErrInvalidLengthGenerated
7487                         }
7488                         postIndex := iNdEx + msglen
7489                         if postIndex > l {
7490                                 return io.ErrUnexpectedEOF
7491                         }
7492                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7493                                 return err
7494                         }
7495                         iNdEx = postIndex
7496                 default:
7497                         iNdEx = preIndex
7498                         skippy, err := skipGenerated(dAtA[iNdEx:])
7499                         if err != nil {
7500                                 return err
7501                         }
7502                         if skippy < 0 {
7503                                 return ErrInvalidLengthGenerated
7504                         }
7505                         if (iNdEx + skippy) > l {
7506                                 return io.ErrUnexpectedEOF
7507                         }
7508                         iNdEx += skippy
7509                 }
7510         }
7511
7512         if iNdEx > l {
7513                 return io.ErrUnexpectedEOF
7514         }
7515         return nil
7516 }
7517 func (m *IngressBackend) Unmarshal(dAtA []byte) error {
7518         l := len(dAtA)
7519         iNdEx := 0
7520         for iNdEx < l {
7521                 preIndex := iNdEx
7522                 var wire uint64
7523                 for shift := uint(0); ; shift += 7 {
7524                         if shift >= 64 {
7525                                 return ErrIntOverflowGenerated
7526                         }
7527                         if iNdEx >= l {
7528                                 return io.ErrUnexpectedEOF
7529                         }
7530                         b := dAtA[iNdEx]
7531                         iNdEx++
7532                         wire |= (uint64(b) & 0x7F) << shift
7533                         if b < 0x80 {
7534                                 break
7535                         }
7536                 }
7537                 fieldNum := int32(wire >> 3)
7538                 wireType := int(wire & 0x7)
7539                 if wireType == 4 {
7540                         return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group")
7541                 }
7542                 if fieldNum <= 0 {
7543                         return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire)
7544                 }
7545                 switch fieldNum {
7546                 case 1:
7547                         if wireType != 2 {
7548                                 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
7549                         }
7550                         var stringLen uint64
7551                         for shift := uint(0); ; shift += 7 {
7552                                 if shift >= 64 {
7553                                         return ErrIntOverflowGenerated
7554                                 }
7555                                 if iNdEx >= l {
7556                                         return io.ErrUnexpectedEOF
7557                                 }
7558                                 b := dAtA[iNdEx]
7559                                 iNdEx++
7560                                 stringLen |= (uint64(b) & 0x7F) << shift
7561                                 if b < 0x80 {
7562                                         break
7563                                 }
7564                         }
7565                         intStringLen := int(stringLen)
7566                         if intStringLen < 0 {
7567                                 return ErrInvalidLengthGenerated
7568                         }
7569                         postIndex := iNdEx + intStringLen
7570                         if postIndex > l {
7571                                 return io.ErrUnexpectedEOF
7572                         }
7573                         m.ServiceName = string(dAtA[iNdEx:postIndex])
7574                         iNdEx = postIndex
7575                 case 2:
7576                         if wireType != 2 {
7577                                 return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
7578                         }
7579                         var msglen int
7580                         for shift := uint(0); ; shift += 7 {
7581                                 if shift >= 64 {
7582                                         return ErrIntOverflowGenerated
7583                                 }
7584                                 if iNdEx >= l {
7585                                         return io.ErrUnexpectedEOF
7586                                 }
7587                                 b := dAtA[iNdEx]
7588                                 iNdEx++
7589                                 msglen |= (int(b) & 0x7F) << shift
7590                                 if b < 0x80 {
7591                                         break
7592                                 }
7593                         }
7594                         if msglen < 0 {
7595                                 return ErrInvalidLengthGenerated
7596                         }
7597                         postIndex := iNdEx + msglen
7598                         if postIndex > l {
7599                                 return io.ErrUnexpectedEOF
7600                         }
7601                         if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7602                                 return err
7603                         }
7604                         iNdEx = postIndex
7605                 default:
7606                         iNdEx = preIndex
7607                         skippy, err := skipGenerated(dAtA[iNdEx:])
7608                         if err != nil {
7609                                 return err
7610                         }
7611                         if skippy < 0 {
7612                                 return ErrInvalidLengthGenerated
7613                         }
7614                         if (iNdEx + skippy) > l {
7615                                 return io.ErrUnexpectedEOF
7616                         }
7617                         iNdEx += skippy
7618                 }
7619         }
7620
7621         if iNdEx > l {
7622                 return io.ErrUnexpectedEOF
7623         }
7624         return nil
7625 }
7626 func (m *IngressList) Unmarshal(dAtA []byte) error {
7627         l := len(dAtA)
7628         iNdEx := 0
7629         for iNdEx < l {
7630                 preIndex := iNdEx
7631                 var wire uint64
7632                 for shift := uint(0); ; shift += 7 {
7633                         if shift >= 64 {
7634                                 return ErrIntOverflowGenerated
7635                         }
7636                         if iNdEx >= l {
7637                                 return io.ErrUnexpectedEOF
7638                         }
7639                         b := dAtA[iNdEx]
7640                         iNdEx++
7641                         wire |= (uint64(b) & 0x7F) << shift
7642                         if b < 0x80 {
7643                                 break
7644                         }
7645                 }
7646                 fieldNum := int32(wire >> 3)
7647                 wireType := int(wire & 0x7)
7648                 if wireType == 4 {
7649                         return fmt.Errorf("proto: IngressList: wiretype end group for non-group")
7650                 }
7651                 if fieldNum <= 0 {
7652                         return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire)
7653                 }
7654                 switch fieldNum {
7655                 case 1:
7656                         if wireType != 2 {
7657                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
7658                         }
7659                         var msglen int
7660                         for shift := uint(0); ; shift += 7 {
7661                                 if shift >= 64 {
7662                                         return ErrIntOverflowGenerated
7663                                 }
7664                                 if iNdEx >= l {
7665                                         return io.ErrUnexpectedEOF
7666                                 }
7667                                 b := dAtA[iNdEx]
7668                                 iNdEx++
7669                                 msglen |= (int(b) & 0x7F) << shift
7670                                 if b < 0x80 {
7671                                         break
7672                                 }
7673                         }
7674                         if msglen < 0 {
7675                                 return ErrInvalidLengthGenerated
7676                         }
7677                         postIndex := iNdEx + msglen
7678                         if postIndex > l {
7679                                 return io.ErrUnexpectedEOF
7680                         }
7681                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7682                                 return err
7683                         }
7684                         iNdEx = postIndex
7685                 case 2:
7686                         if wireType != 2 {
7687                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7688                         }
7689                         var msglen int
7690                         for shift := uint(0); ; shift += 7 {
7691                                 if shift >= 64 {
7692                                         return ErrIntOverflowGenerated
7693                                 }
7694                                 if iNdEx >= l {
7695                                         return io.ErrUnexpectedEOF
7696                                 }
7697                                 b := dAtA[iNdEx]
7698                                 iNdEx++
7699                                 msglen |= (int(b) & 0x7F) << shift
7700                                 if b < 0x80 {
7701                                         break
7702                                 }
7703                         }
7704                         if msglen < 0 {
7705                                 return ErrInvalidLengthGenerated
7706                         }
7707                         postIndex := iNdEx + msglen
7708                         if postIndex > l {
7709                                 return io.ErrUnexpectedEOF
7710                         }
7711                         m.Items = append(m.Items, Ingress{})
7712                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7713                                 return err
7714                         }
7715                         iNdEx = postIndex
7716                 default:
7717                         iNdEx = preIndex
7718                         skippy, err := skipGenerated(dAtA[iNdEx:])
7719                         if err != nil {
7720                                 return err
7721                         }
7722                         if skippy < 0 {
7723                                 return ErrInvalidLengthGenerated
7724                         }
7725                         if (iNdEx + skippy) > l {
7726                                 return io.ErrUnexpectedEOF
7727                         }
7728                         iNdEx += skippy
7729                 }
7730         }
7731
7732         if iNdEx > l {
7733                 return io.ErrUnexpectedEOF
7734         }
7735         return nil
7736 }
7737 func (m *IngressRule) Unmarshal(dAtA []byte) error {
7738         l := len(dAtA)
7739         iNdEx := 0
7740         for iNdEx < l {
7741                 preIndex := iNdEx
7742                 var wire uint64
7743                 for shift := uint(0); ; shift += 7 {
7744                         if shift >= 64 {
7745                                 return ErrIntOverflowGenerated
7746                         }
7747                         if iNdEx >= l {
7748                                 return io.ErrUnexpectedEOF
7749                         }
7750                         b := dAtA[iNdEx]
7751                         iNdEx++
7752                         wire |= (uint64(b) & 0x7F) << shift
7753                         if b < 0x80 {
7754                                 break
7755                         }
7756                 }
7757                 fieldNum := int32(wire >> 3)
7758                 wireType := int(wire & 0x7)
7759                 if wireType == 4 {
7760                         return fmt.Errorf("proto: IngressRule: wiretype end group for non-group")
7761                 }
7762                 if fieldNum <= 0 {
7763                         return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
7764                 }
7765                 switch fieldNum {
7766                 case 1:
7767                         if wireType != 2 {
7768                                 return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
7769                         }
7770                         var stringLen uint64
7771                         for shift := uint(0); ; shift += 7 {
7772                                 if shift >= 64 {
7773                                         return ErrIntOverflowGenerated
7774                                 }
7775                                 if iNdEx >= l {
7776                                         return io.ErrUnexpectedEOF
7777                                 }
7778                                 b := dAtA[iNdEx]
7779                                 iNdEx++
7780                                 stringLen |= (uint64(b) & 0x7F) << shift
7781                                 if b < 0x80 {
7782                                         break
7783                                 }
7784                         }
7785                         intStringLen := int(stringLen)
7786                         if intStringLen < 0 {
7787                                 return ErrInvalidLengthGenerated
7788                         }
7789                         postIndex := iNdEx + intStringLen
7790                         if postIndex > l {
7791                                 return io.ErrUnexpectedEOF
7792                         }
7793                         m.Host = string(dAtA[iNdEx:postIndex])
7794                         iNdEx = postIndex
7795                 case 2:
7796                         if wireType != 2 {
7797                                 return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType)
7798                         }
7799                         var msglen int
7800                         for shift := uint(0); ; shift += 7 {
7801                                 if shift >= 64 {
7802                                         return ErrIntOverflowGenerated
7803                                 }
7804                                 if iNdEx >= l {
7805                                         return io.ErrUnexpectedEOF
7806                                 }
7807                                 b := dAtA[iNdEx]
7808                                 iNdEx++
7809                                 msglen |= (int(b) & 0x7F) << shift
7810                                 if b < 0x80 {
7811                                         break
7812                                 }
7813                         }
7814                         if msglen < 0 {
7815                                 return ErrInvalidLengthGenerated
7816                         }
7817                         postIndex := iNdEx + msglen
7818                         if postIndex > l {
7819                                 return io.ErrUnexpectedEOF
7820                         }
7821                         if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7822                                 return err
7823                         }
7824                         iNdEx = postIndex
7825                 default:
7826                         iNdEx = preIndex
7827                         skippy, err := skipGenerated(dAtA[iNdEx:])
7828                         if err != nil {
7829                                 return err
7830                         }
7831                         if skippy < 0 {
7832                                 return ErrInvalidLengthGenerated
7833                         }
7834                         if (iNdEx + skippy) > l {
7835                                 return io.ErrUnexpectedEOF
7836                         }
7837                         iNdEx += skippy
7838                 }
7839         }
7840
7841         if iNdEx > l {
7842                 return io.ErrUnexpectedEOF
7843         }
7844         return nil
7845 }
7846 func (m *IngressRuleValue) Unmarshal(dAtA []byte) error {
7847         l := len(dAtA)
7848         iNdEx := 0
7849         for iNdEx < l {
7850                 preIndex := iNdEx
7851                 var wire uint64
7852                 for shift := uint(0); ; shift += 7 {
7853                         if shift >= 64 {
7854                                 return ErrIntOverflowGenerated
7855                         }
7856                         if iNdEx >= l {
7857                                 return io.ErrUnexpectedEOF
7858                         }
7859                         b := dAtA[iNdEx]
7860                         iNdEx++
7861                         wire |= (uint64(b) & 0x7F) << shift
7862                         if b < 0x80 {
7863                                 break
7864                         }
7865                 }
7866                 fieldNum := int32(wire >> 3)
7867                 wireType := int(wire & 0x7)
7868                 if wireType == 4 {
7869                         return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group")
7870                 }
7871                 if fieldNum <= 0 {
7872                         return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
7873                 }
7874                 switch fieldNum {
7875                 case 1:
7876                         if wireType != 2 {
7877                                 return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType)
7878                         }
7879                         var msglen int
7880                         for shift := uint(0); ; shift += 7 {
7881                                 if shift >= 64 {
7882                                         return ErrIntOverflowGenerated
7883                                 }
7884                                 if iNdEx >= l {
7885                                         return io.ErrUnexpectedEOF
7886                                 }
7887                                 b := dAtA[iNdEx]
7888                                 iNdEx++
7889                                 msglen |= (int(b) & 0x7F) << shift
7890                                 if b < 0x80 {
7891                                         break
7892                                 }
7893                         }
7894                         if msglen < 0 {
7895                                 return ErrInvalidLengthGenerated
7896                         }
7897                         postIndex := iNdEx + msglen
7898                         if postIndex > l {
7899                                 return io.ErrUnexpectedEOF
7900                         }
7901                         if m.HTTP == nil {
7902                                 m.HTTP = &HTTPIngressRuleValue{}
7903                         }
7904                         if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7905                                 return err
7906                         }
7907                         iNdEx = postIndex
7908                 default:
7909                         iNdEx = preIndex
7910                         skippy, err := skipGenerated(dAtA[iNdEx:])
7911                         if err != nil {
7912                                 return err
7913                         }
7914                         if skippy < 0 {
7915                                 return ErrInvalidLengthGenerated
7916                         }
7917                         if (iNdEx + skippy) > l {
7918                                 return io.ErrUnexpectedEOF
7919                         }
7920                         iNdEx += skippy
7921                 }
7922         }
7923
7924         if iNdEx > l {
7925                 return io.ErrUnexpectedEOF
7926         }
7927         return nil
7928 }
7929 func (m *IngressSpec) Unmarshal(dAtA []byte) error {
7930         l := len(dAtA)
7931         iNdEx := 0
7932         for iNdEx < l {
7933                 preIndex := iNdEx
7934                 var wire uint64
7935                 for shift := uint(0); ; shift += 7 {
7936                         if shift >= 64 {
7937                                 return ErrIntOverflowGenerated
7938                         }
7939                         if iNdEx >= l {
7940                                 return io.ErrUnexpectedEOF
7941                         }
7942                         b := dAtA[iNdEx]
7943                         iNdEx++
7944                         wire |= (uint64(b) & 0x7F) << shift
7945                         if b < 0x80 {
7946                                 break
7947                         }
7948                 }
7949                 fieldNum := int32(wire >> 3)
7950                 wireType := int(wire & 0x7)
7951                 if wireType == 4 {
7952                         return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group")
7953                 }
7954                 if fieldNum <= 0 {
7955                         return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
7956                 }
7957                 switch fieldNum {
7958                 case 1:
7959                         if wireType != 2 {
7960                                 return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
7961                         }
7962                         var msglen int
7963                         for shift := uint(0); ; shift += 7 {
7964                                 if shift >= 64 {
7965                                         return ErrIntOverflowGenerated
7966                                 }
7967                                 if iNdEx >= l {
7968                                         return io.ErrUnexpectedEOF
7969                                 }
7970                                 b := dAtA[iNdEx]
7971                                 iNdEx++
7972                                 msglen |= (int(b) & 0x7F) << shift
7973                                 if b < 0x80 {
7974                                         break
7975                                 }
7976                         }
7977                         if msglen < 0 {
7978                                 return ErrInvalidLengthGenerated
7979                         }
7980                         postIndex := iNdEx + msglen
7981                         if postIndex > l {
7982                                 return io.ErrUnexpectedEOF
7983                         }
7984                         if m.Backend == nil {
7985                                 m.Backend = &IngressBackend{}
7986                         }
7987                         if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7988                                 return err
7989                         }
7990                         iNdEx = postIndex
7991                 case 2:
7992                         if wireType != 2 {
7993                                 return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
7994                         }
7995                         var msglen int
7996                         for shift := uint(0); ; shift += 7 {
7997                                 if shift >= 64 {
7998                                         return ErrIntOverflowGenerated
7999                                 }
8000                                 if iNdEx >= l {
8001                                         return io.ErrUnexpectedEOF
8002                                 }
8003                                 b := dAtA[iNdEx]
8004                                 iNdEx++
8005                                 msglen |= (int(b) & 0x7F) << shift
8006                                 if b < 0x80 {
8007                                         break
8008                                 }
8009                         }
8010                         if msglen < 0 {
8011                                 return ErrInvalidLengthGenerated
8012                         }
8013                         postIndex := iNdEx + msglen
8014                         if postIndex > l {
8015                                 return io.ErrUnexpectedEOF
8016                         }
8017                         m.TLS = append(m.TLS, IngressTLS{})
8018                         if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8019                                 return err
8020                         }
8021                         iNdEx = postIndex
8022                 case 3:
8023                         if wireType != 2 {
8024                                 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
8025                         }
8026                         var msglen int
8027                         for shift := uint(0); ; shift += 7 {
8028                                 if shift >= 64 {
8029                                         return ErrIntOverflowGenerated
8030                                 }
8031                                 if iNdEx >= l {
8032                                         return io.ErrUnexpectedEOF
8033                                 }
8034                                 b := dAtA[iNdEx]
8035                                 iNdEx++
8036                                 msglen |= (int(b) & 0x7F) << shift
8037                                 if b < 0x80 {
8038                                         break
8039                                 }
8040                         }
8041                         if msglen < 0 {
8042                                 return ErrInvalidLengthGenerated
8043                         }
8044                         postIndex := iNdEx + msglen
8045                         if postIndex > l {
8046                                 return io.ErrUnexpectedEOF
8047                         }
8048                         m.Rules = append(m.Rules, IngressRule{})
8049                         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8050                                 return err
8051                         }
8052                         iNdEx = postIndex
8053                 default:
8054                         iNdEx = preIndex
8055                         skippy, err := skipGenerated(dAtA[iNdEx:])
8056                         if err != nil {
8057                                 return err
8058                         }
8059                         if skippy < 0 {
8060                                 return ErrInvalidLengthGenerated
8061                         }
8062                         if (iNdEx + skippy) > l {
8063                                 return io.ErrUnexpectedEOF
8064                         }
8065                         iNdEx += skippy
8066                 }
8067         }
8068
8069         if iNdEx > l {
8070                 return io.ErrUnexpectedEOF
8071         }
8072         return nil
8073 }
8074 func (m *IngressStatus) Unmarshal(dAtA []byte) error {
8075         l := len(dAtA)
8076         iNdEx := 0
8077         for iNdEx < l {
8078                 preIndex := iNdEx
8079                 var wire uint64
8080                 for shift := uint(0); ; shift += 7 {
8081                         if shift >= 64 {
8082                                 return ErrIntOverflowGenerated
8083                         }
8084                         if iNdEx >= l {
8085                                 return io.ErrUnexpectedEOF
8086                         }
8087                         b := dAtA[iNdEx]
8088                         iNdEx++
8089                         wire |= (uint64(b) & 0x7F) << shift
8090                         if b < 0x80 {
8091                                 break
8092                         }
8093                 }
8094                 fieldNum := int32(wire >> 3)
8095                 wireType := int(wire & 0x7)
8096                 if wireType == 4 {
8097                         return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group")
8098                 }
8099                 if fieldNum <= 0 {
8100                         return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire)
8101                 }
8102                 switch fieldNum {
8103                 case 1:
8104                         if wireType != 2 {
8105                                 return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
8106                         }
8107                         var msglen int
8108                         for shift := uint(0); ; shift += 7 {
8109                                 if shift >= 64 {
8110                                         return ErrIntOverflowGenerated
8111                                 }
8112                                 if iNdEx >= l {
8113                                         return io.ErrUnexpectedEOF
8114                                 }
8115                                 b := dAtA[iNdEx]
8116                                 iNdEx++
8117                                 msglen |= (int(b) & 0x7F) << shift
8118                                 if b < 0x80 {
8119                                         break
8120                                 }
8121                         }
8122                         if msglen < 0 {
8123                                 return ErrInvalidLengthGenerated
8124                         }
8125                         postIndex := iNdEx + msglen
8126                         if postIndex > l {
8127                                 return io.ErrUnexpectedEOF
8128                         }
8129                         if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8130                                 return err
8131                         }
8132                         iNdEx = postIndex
8133                 default:
8134                         iNdEx = preIndex
8135                         skippy, err := skipGenerated(dAtA[iNdEx:])
8136                         if err != nil {
8137                                 return err
8138                         }
8139                         if skippy < 0 {
8140                                 return ErrInvalidLengthGenerated
8141                         }
8142                         if (iNdEx + skippy) > l {
8143                                 return io.ErrUnexpectedEOF
8144                         }
8145                         iNdEx += skippy
8146                 }
8147         }
8148
8149         if iNdEx > l {
8150                 return io.ErrUnexpectedEOF
8151         }
8152         return nil
8153 }
8154 func (m *IngressTLS) Unmarshal(dAtA []byte) error {
8155         l := len(dAtA)
8156         iNdEx := 0
8157         for iNdEx < l {
8158                 preIndex := iNdEx
8159                 var wire uint64
8160                 for shift := uint(0); ; shift += 7 {
8161                         if shift >= 64 {
8162                                 return ErrIntOverflowGenerated
8163                         }
8164                         if iNdEx >= l {
8165                                 return io.ErrUnexpectedEOF
8166                         }
8167                         b := dAtA[iNdEx]
8168                         iNdEx++
8169                         wire |= (uint64(b) & 0x7F) << shift
8170                         if b < 0x80 {
8171                                 break
8172                         }
8173                 }
8174                 fieldNum := int32(wire >> 3)
8175                 wireType := int(wire & 0x7)
8176                 if wireType == 4 {
8177                         return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group")
8178                 }
8179                 if fieldNum <= 0 {
8180                         return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire)
8181                 }
8182                 switch fieldNum {
8183                 case 1:
8184                         if wireType != 2 {
8185                                 return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
8186                         }
8187                         var stringLen uint64
8188                         for shift := uint(0); ; shift += 7 {
8189                                 if shift >= 64 {
8190                                         return ErrIntOverflowGenerated
8191                                 }
8192                                 if iNdEx >= l {
8193                                         return io.ErrUnexpectedEOF
8194                                 }
8195                                 b := dAtA[iNdEx]
8196                                 iNdEx++
8197                                 stringLen |= (uint64(b) & 0x7F) << shift
8198                                 if b < 0x80 {
8199                                         break
8200                                 }
8201                         }
8202                         intStringLen := int(stringLen)
8203                         if intStringLen < 0 {
8204                                 return ErrInvalidLengthGenerated
8205                         }
8206                         postIndex := iNdEx + intStringLen
8207                         if postIndex > l {
8208                                 return io.ErrUnexpectedEOF
8209                         }
8210                         m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex]))
8211                         iNdEx = postIndex
8212                 case 2:
8213                         if wireType != 2 {
8214                                 return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
8215                         }
8216                         var stringLen uint64
8217                         for shift := uint(0); ; shift += 7 {
8218                                 if shift >= 64 {
8219                                         return ErrIntOverflowGenerated
8220                                 }
8221                                 if iNdEx >= l {
8222                                         return io.ErrUnexpectedEOF
8223                                 }
8224                                 b := dAtA[iNdEx]
8225                                 iNdEx++
8226                                 stringLen |= (uint64(b) & 0x7F) << shift
8227                                 if b < 0x80 {
8228                                         break
8229                                 }
8230                         }
8231                         intStringLen := int(stringLen)
8232                         if intStringLen < 0 {
8233                                 return ErrInvalidLengthGenerated
8234                         }
8235                         postIndex := iNdEx + intStringLen
8236                         if postIndex > l {
8237                                 return io.ErrUnexpectedEOF
8238                         }
8239                         m.SecretName = string(dAtA[iNdEx:postIndex])
8240                         iNdEx = postIndex
8241                 default:
8242                         iNdEx = preIndex
8243                         skippy, err := skipGenerated(dAtA[iNdEx:])
8244                         if err != nil {
8245                                 return err
8246                         }
8247                         if skippy < 0 {
8248                                 return ErrInvalidLengthGenerated
8249                         }
8250                         if (iNdEx + skippy) > l {
8251                                 return io.ErrUnexpectedEOF
8252                         }
8253                         iNdEx += skippy
8254                 }
8255         }
8256
8257         if iNdEx > l {
8258                 return io.ErrUnexpectedEOF
8259         }
8260         return nil
8261 }
8262 func (m *NetworkPolicy) Unmarshal(dAtA []byte) error {
8263         l := len(dAtA)
8264         iNdEx := 0
8265         for iNdEx < l {
8266                 preIndex := iNdEx
8267                 var wire uint64
8268                 for shift := uint(0); ; shift += 7 {
8269                         if shift >= 64 {
8270                                 return ErrIntOverflowGenerated
8271                         }
8272                         if iNdEx >= l {
8273                                 return io.ErrUnexpectedEOF
8274                         }
8275                         b := dAtA[iNdEx]
8276                         iNdEx++
8277                         wire |= (uint64(b) & 0x7F) << shift
8278                         if b < 0x80 {
8279                                 break
8280                         }
8281                 }
8282                 fieldNum := int32(wire >> 3)
8283                 wireType := int(wire & 0x7)
8284                 if wireType == 4 {
8285                         return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group")
8286                 }
8287                 if fieldNum <= 0 {
8288                         return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
8289                 }
8290                 switch fieldNum {
8291                 case 1:
8292                         if wireType != 2 {
8293                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
8294                         }
8295                         var msglen int
8296                         for shift := uint(0); ; shift += 7 {
8297                                 if shift >= 64 {
8298                                         return ErrIntOverflowGenerated
8299                                 }
8300                                 if iNdEx >= l {
8301                                         return io.ErrUnexpectedEOF
8302                                 }
8303                                 b := dAtA[iNdEx]
8304                                 iNdEx++
8305                                 msglen |= (int(b) & 0x7F) << shift
8306                                 if b < 0x80 {
8307                                         break
8308                                 }
8309                         }
8310                         if msglen < 0 {
8311                                 return ErrInvalidLengthGenerated
8312                         }
8313                         postIndex := iNdEx + msglen
8314                         if postIndex > l {
8315                                 return io.ErrUnexpectedEOF
8316                         }
8317                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8318                                 return err
8319                         }
8320                         iNdEx = postIndex
8321                 case 2:
8322                         if wireType != 2 {
8323                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
8324                         }
8325                         var msglen int
8326                         for shift := uint(0); ; shift += 7 {
8327                                 if shift >= 64 {
8328                                         return ErrIntOverflowGenerated
8329                                 }
8330                                 if iNdEx >= l {
8331                                         return io.ErrUnexpectedEOF
8332                                 }
8333                                 b := dAtA[iNdEx]
8334                                 iNdEx++
8335                                 msglen |= (int(b) & 0x7F) << shift
8336                                 if b < 0x80 {
8337                                         break
8338                                 }
8339                         }
8340                         if msglen < 0 {
8341                                 return ErrInvalidLengthGenerated
8342                         }
8343                         postIndex := iNdEx + msglen
8344                         if postIndex > l {
8345                                 return io.ErrUnexpectedEOF
8346                         }
8347                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8348                                 return err
8349                         }
8350                         iNdEx = postIndex
8351                 default:
8352                         iNdEx = preIndex
8353                         skippy, err := skipGenerated(dAtA[iNdEx:])
8354                         if err != nil {
8355                                 return err
8356                         }
8357                         if skippy < 0 {
8358                                 return ErrInvalidLengthGenerated
8359                         }
8360                         if (iNdEx + skippy) > l {
8361                                 return io.ErrUnexpectedEOF
8362                         }
8363                         iNdEx += skippy
8364                 }
8365         }
8366
8367         if iNdEx > l {
8368                 return io.ErrUnexpectedEOF
8369         }
8370         return nil
8371 }
8372 func (m *NetworkPolicyEgressRule) Unmarshal(dAtA []byte) error {
8373         l := len(dAtA)
8374         iNdEx := 0
8375         for iNdEx < l {
8376                 preIndex := iNdEx
8377                 var wire uint64
8378                 for shift := uint(0); ; shift += 7 {
8379                         if shift >= 64 {
8380                                 return ErrIntOverflowGenerated
8381                         }
8382                         if iNdEx >= l {
8383                                 return io.ErrUnexpectedEOF
8384                         }
8385                         b := dAtA[iNdEx]
8386                         iNdEx++
8387                         wire |= (uint64(b) & 0x7F) << shift
8388                         if b < 0x80 {
8389                                 break
8390                         }
8391                 }
8392                 fieldNum := int32(wire >> 3)
8393                 wireType := int(wire & 0x7)
8394                 if wireType == 4 {
8395                         return fmt.Errorf("proto: NetworkPolicyEgressRule: wiretype end group for non-group")
8396                 }
8397                 if fieldNum <= 0 {
8398                         return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8399                 }
8400                 switch fieldNum {
8401                 case 1:
8402                         if wireType != 2 {
8403                                 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
8404                         }
8405                         var msglen int
8406                         for shift := uint(0); ; shift += 7 {
8407                                 if shift >= 64 {
8408                                         return ErrIntOverflowGenerated
8409                                 }
8410                                 if iNdEx >= l {
8411                                         return io.ErrUnexpectedEOF
8412                                 }
8413                                 b := dAtA[iNdEx]
8414                                 iNdEx++
8415                                 msglen |= (int(b) & 0x7F) << shift
8416                                 if b < 0x80 {
8417                                         break
8418                                 }
8419                         }
8420                         if msglen < 0 {
8421                                 return ErrInvalidLengthGenerated
8422                         }
8423                         postIndex := iNdEx + msglen
8424                         if postIndex > l {
8425                                 return io.ErrUnexpectedEOF
8426                         }
8427                         m.Ports = append(m.Ports, NetworkPolicyPort{})
8428                         if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8429                                 return err
8430                         }
8431                         iNdEx = postIndex
8432                 case 2:
8433                         if wireType != 2 {
8434                                 return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
8435                         }
8436                         var msglen int
8437                         for shift := uint(0); ; shift += 7 {
8438                                 if shift >= 64 {
8439                                         return ErrIntOverflowGenerated
8440                                 }
8441                                 if iNdEx >= l {
8442                                         return io.ErrUnexpectedEOF
8443                                 }
8444                                 b := dAtA[iNdEx]
8445                                 iNdEx++
8446                                 msglen |= (int(b) & 0x7F) << shift
8447                                 if b < 0x80 {
8448                                         break
8449                                 }
8450                         }
8451                         if msglen < 0 {
8452                                 return ErrInvalidLengthGenerated
8453                         }
8454                         postIndex := iNdEx + msglen
8455                         if postIndex > l {
8456                                 return io.ErrUnexpectedEOF
8457                         }
8458                         m.To = append(m.To, NetworkPolicyPeer{})
8459                         if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8460                                 return err
8461                         }
8462                         iNdEx = postIndex
8463                 default:
8464                         iNdEx = preIndex
8465                         skippy, err := skipGenerated(dAtA[iNdEx:])
8466                         if err != nil {
8467                                 return err
8468                         }
8469                         if skippy < 0 {
8470                                 return ErrInvalidLengthGenerated
8471                         }
8472                         if (iNdEx + skippy) > l {
8473                                 return io.ErrUnexpectedEOF
8474                         }
8475                         iNdEx += skippy
8476                 }
8477         }
8478
8479         if iNdEx > l {
8480                 return io.ErrUnexpectedEOF
8481         }
8482         return nil
8483 }
8484 func (m *NetworkPolicyIngressRule) Unmarshal(dAtA []byte) error {
8485         l := len(dAtA)
8486         iNdEx := 0
8487         for iNdEx < l {
8488                 preIndex := iNdEx
8489                 var wire uint64
8490                 for shift := uint(0); ; shift += 7 {
8491                         if shift >= 64 {
8492                                 return ErrIntOverflowGenerated
8493                         }
8494                         if iNdEx >= l {
8495                                 return io.ErrUnexpectedEOF
8496                         }
8497                         b := dAtA[iNdEx]
8498                         iNdEx++
8499                         wire |= (uint64(b) & 0x7F) << shift
8500                         if b < 0x80 {
8501                                 break
8502                         }
8503                 }
8504                 fieldNum := int32(wire >> 3)
8505                 wireType := int(wire & 0x7)
8506                 if wireType == 4 {
8507                         return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group")
8508                 }
8509                 if fieldNum <= 0 {
8510                         return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8511                 }
8512                 switch fieldNum {
8513                 case 1:
8514                         if wireType != 2 {
8515                                 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
8516                         }
8517                         var msglen int
8518                         for shift := uint(0); ; shift += 7 {
8519                                 if shift >= 64 {
8520                                         return ErrIntOverflowGenerated
8521                                 }
8522                                 if iNdEx >= l {
8523                                         return io.ErrUnexpectedEOF
8524                                 }
8525                                 b := dAtA[iNdEx]
8526                                 iNdEx++
8527                                 msglen |= (int(b) & 0x7F) << shift
8528                                 if b < 0x80 {
8529                                         break
8530                                 }
8531                         }
8532                         if msglen < 0 {
8533                                 return ErrInvalidLengthGenerated
8534                         }
8535                         postIndex := iNdEx + msglen
8536                         if postIndex > l {
8537                                 return io.ErrUnexpectedEOF
8538                         }
8539                         m.Ports = append(m.Ports, NetworkPolicyPort{})
8540                         if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8541                                 return err
8542                         }
8543                         iNdEx = postIndex
8544                 case 2:
8545                         if wireType != 2 {
8546                                 return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
8547                         }
8548                         var msglen int
8549                         for shift := uint(0); ; shift += 7 {
8550                                 if shift >= 64 {
8551                                         return ErrIntOverflowGenerated
8552                                 }
8553                                 if iNdEx >= l {
8554                                         return io.ErrUnexpectedEOF
8555                                 }
8556                                 b := dAtA[iNdEx]
8557                                 iNdEx++
8558                                 msglen |= (int(b) & 0x7F) << shift
8559                                 if b < 0x80 {
8560                                         break
8561                                 }
8562                         }
8563                         if msglen < 0 {
8564                                 return ErrInvalidLengthGenerated
8565                         }
8566                         postIndex := iNdEx + msglen
8567                         if postIndex > l {
8568                                 return io.ErrUnexpectedEOF
8569                         }
8570                         m.From = append(m.From, NetworkPolicyPeer{})
8571                         if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8572                                 return err
8573                         }
8574                         iNdEx = postIndex
8575                 default:
8576                         iNdEx = preIndex
8577                         skippy, err := skipGenerated(dAtA[iNdEx:])
8578                         if err != nil {
8579                                 return err
8580                         }
8581                         if skippy < 0 {
8582                                 return ErrInvalidLengthGenerated
8583                         }
8584                         if (iNdEx + skippy) > l {
8585                                 return io.ErrUnexpectedEOF
8586                         }
8587                         iNdEx += skippy
8588                 }
8589         }
8590
8591         if iNdEx > l {
8592                 return io.ErrUnexpectedEOF
8593         }
8594         return nil
8595 }
8596 func (m *NetworkPolicyList) Unmarshal(dAtA []byte) error {
8597         l := len(dAtA)
8598         iNdEx := 0
8599         for iNdEx < l {
8600                 preIndex := iNdEx
8601                 var wire uint64
8602                 for shift := uint(0); ; shift += 7 {
8603                         if shift >= 64 {
8604                                 return ErrIntOverflowGenerated
8605                         }
8606                         if iNdEx >= l {
8607                                 return io.ErrUnexpectedEOF
8608                         }
8609                         b := dAtA[iNdEx]
8610                         iNdEx++
8611                         wire |= (uint64(b) & 0x7F) << shift
8612                         if b < 0x80 {
8613                                 break
8614                         }
8615                 }
8616                 fieldNum := int32(wire >> 3)
8617                 wireType := int(wire & 0x7)
8618                 if wireType == 4 {
8619                         return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group")
8620                 }
8621                 if fieldNum <= 0 {
8622                         return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
8623                 }
8624                 switch fieldNum {
8625                 case 1:
8626                         if wireType != 2 {
8627                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
8628                         }
8629                         var msglen int
8630                         for shift := uint(0); ; shift += 7 {
8631                                 if shift >= 64 {
8632                                         return ErrIntOverflowGenerated
8633                                 }
8634                                 if iNdEx >= l {
8635                                         return io.ErrUnexpectedEOF
8636                                 }
8637                                 b := dAtA[iNdEx]
8638                                 iNdEx++
8639                                 msglen |= (int(b) & 0x7F) << shift
8640                                 if b < 0x80 {
8641                                         break
8642                                 }
8643                         }
8644                         if msglen < 0 {
8645                                 return ErrInvalidLengthGenerated
8646                         }
8647                         postIndex := iNdEx + msglen
8648                         if postIndex > l {
8649                                 return io.ErrUnexpectedEOF
8650                         }
8651                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8652                                 return err
8653                         }
8654                         iNdEx = postIndex
8655                 case 2:
8656                         if wireType != 2 {
8657                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
8658                         }
8659                         var msglen int
8660                         for shift := uint(0); ; shift += 7 {
8661                                 if shift >= 64 {
8662                                         return ErrIntOverflowGenerated
8663                                 }
8664                                 if iNdEx >= l {
8665                                         return io.ErrUnexpectedEOF
8666                                 }
8667                                 b := dAtA[iNdEx]
8668                                 iNdEx++
8669                                 msglen |= (int(b) & 0x7F) << shift
8670                                 if b < 0x80 {
8671                                         break
8672                                 }
8673                         }
8674                         if msglen < 0 {
8675                                 return ErrInvalidLengthGenerated
8676                         }
8677                         postIndex := iNdEx + msglen
8678                         if postIndex > l {
8679                                 return io.ErrUnexpectedEOF
8680                         }
8681                         m.Items = append(m.Items, NetworkPolicy{})
8682                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8683                                 return err
8684                         }
8685                         iNdEx = postIndex
8686                 default:
8687                         iNdEx = preIndex
8688                         skippy, err := skipGenerated(dAtA[iNdEx:])
8689                         if err != nil {
8690                                 return err
8691                         }
8692                         if skippy < 0 {
8693                                 return ErrInvalidLengthGenerated
8694                         }
8695                         if (iNdEx + skippy) > l {
8696                                 return io.ErrUnexpectedEOF
8697                         }
8698                         iNdEx += skippy
8699                 }
8700         }
8701
8702         if iNdEx > l {
8703                 return io.ErrUnexpectedEOF
8704         }
8705         return nil
8706 }
8707 func (m *NetworkPolicyPeer) Unmarshal(dAtA []byte) error {
8708         l := len(dAtA)
8709         iNdEx := 0
8710         for iNdEx < l {
8711                 preIndex := iNdEx
8712                 var wire uint64
8713                 for shift := uint(0); ; shift += 7 {
8714                         if shift >= 64 {
8715                                 return ErrIntOverflowGenerated
8716                         }
8717                         if iNdEx >= l {
8718                                 return io.ErrUnexpectedEOF
8719                         }
8720                         b := dAtA[iNdEx]
8721                         iNdEx++
8722                         wire |= (uint64(b) & 0x7F) << shift
8723                         if b < 0x80 {
8724                                 break
8725                         }
8726                 }
8727                 fieldNum := int32(wire >> 3)
8728                 wireType := int(wire & 0x7)
8729                 if wireType == 4 {
8730                         return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group")
8731                 }
8732                 if fieldNum <= 0 {
8733                         return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire)
8734                 }
8735                 switch fieldNum {
8736                 case 1:
8737                         if wireType != 2 {
8738                                 return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
8739                         }
8740                         var msglen int
8741                         for shift := uint(0); ; shift += 7 {
8742                                 if shift >= 64 {
8743                                         return ErrIntOverflowGenerated
8744                                 }
8745                                 if iNdEx >= l {
8746                                         return io.ErrUnexpectedEOF
8747                                 }
8748                                 b := dAtA[iNdEx]
8749                                 iNdEx++
8750                                 msglen |= (int(b) & 0x7F) << shift
8751                                 if b < 0x80 {
8752                                         break
8753                                 }
8754                         }
8755                         if msglen < 0 {
8756                                 return ErrInvalidLengthGenerated
8757                         }
8758                         postIndex := iNdEx + msglen
8759                         if postIndex > l {
8760                                 return io.ErrUnexpectedEOF
8761                         }
8762                         if m.PodSelector == nil {
8763                                 m.PodSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
8764                         }
8765                         if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8766                                 return err
8767                         }
8768                         iNdEx = postIndex
8769                 case 2:
8770                         if wireType != 2 {
8771                                 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
8772                         }
8773                         var msglen int
8774                         for shift := uint(0); ; shift += 7 {
8775                                 if shift >= 64 {
8776                                         return ErrIntOverflowGenerated
8777                                 }
8778                                 if iNdEx >= l {
8779                                         return io.ErrUnexpectedEOF
8780                                 }
8781                                 b := dAtA[iNdEx]
8782                                 iNdEx++
8783                                 msglen |= (int(b) & 0x7F) << shift
8784                                 if b < 0x80 {
8785                                         break
8786                                 }
8787                         }
8788                         if msglen < 0 {
8789                                 return ErrInvalidLengthGenerated
8790                         }
8791                         postIndex := iNdEx + msglen
8792                         if postIndex > l {
8793                                 return io.ErrUnexpectedEOF
8794                         }
8795                         if m.NamespaceSelector == nil {
8796                                 m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
8797                         }
8798                         if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8799                                 return err
8800                         }
8801                         iNdEx = postIndex
8802                 case 3:
8803                         if wireType != 2 {
8804                                 return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", wireType)
8805                         }
8806                         var msglen int
8807                         for shift := uint(0); ; shift += 7 {
8808                                 if shift >= 64 {
8809                                         return ErrIntOverflowGenerated
8810                                 }
8811                                 if iNdEx >= l {
8812                                         return io.ErrUnexpectedEOF
8813                                 }
8814                                 b := dAtA[iNdEx]
8815                                 iNdEx++
8816                                 msglen |= (int(b) & 0x7F) << shift
8817                                 if b < 0x80 {
8818                                         break
8819                                 }
8820                         }
8821                         if msglen < 0 {
8822                                 return ErrInvalidLengthGenerated
8823                         }
8824                         postIndex := iNdEx + msglen
8825                         if postIndex > l {
8826                                 return io.ErrUnexpectedEOF
8827                         }
8828                         if m.IPBlock == nil {
8829                                 m.IPBlock = &IPBlock{}
8830                         }
8831                         if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8832                                 return err
8833                         }
8834                         iNdEx = postIndex
8835                 default:
8836                         iNdEx = preIndex
8837                         skippy, err := skipGenerated(dAtA[iNdEx:])
8838                         if err != nil {
8839                                 return err
8840                         }
8841                         if skippy < 0 {
8842                                 return ErrInvalidLengthGenerated
8843                         }
8844                         if (iNdEx + skippy) > l {
8845                                 return io.ErrUnexpectedEOF
8846                         }
8847                         iNdEx += skippy
8848                 }
8849         }
8850
8851         if iNdEx > l {
8852                 return io.ErrUnexpectedEOF
8853         }
8854         return nil
8855 }
8856 func (m *NetworkPolicyPort) Unmarshal(dAtA []byte) error {
8857         l := len(dAtA)
8858         iNdEx := 0
8859         for iNdEx < l {
8860                 preIndex := iNdEx
8861                 var wire uint64
8862                 for shift := uint(0); ; shift += 7 {
8863                         if shift >= 64 {
8864                                 return ErrIntOverflowGenerated
8865                         }
8866                         if iNdEx >= l {
8867                                 return io.ErrUnexpectedEOF
8868                         }
8869                         b := dAtA[iNdEx]
8870                         iNdEx++
8871                         wire |= (uint64(b) & 0x7F) << shift
8872                         if b < 0x80 {
8873                                 break
8874                         }
8875                 }
8876                 fieldNum := int32(wire >> 3)
8877                 wireType := int(wire & 0x7)
8878                 if wireType == 4 {
8879                         return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group")
8880                 }
8881                 if fieldNum <= 0 {
8882                         return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire)
8883                 }
8884                 switch fieldNum {
8885                 case 1:
8886                         if wireType != 2 {
8887                                 return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
8888                         }
8889                         var stringLen uint64
8890                         for shift := uint(0); ; shift += 7 {
8891                                 if shift >= 64 {
8892                                         return ErrIntOverflowGenerated
8893                                 }
8894                                 if iNdEx >= l {
8895                                         return io.ErrUnexpectedEOF
8896                                 }
8897                                 b := dAtA[iNdEx]
8898                                 iNdEx++
8899                                 stringLen |= (uint64(b) & 0x7F) << shift
8900                                 if b < 0x80 {
8901                                         break
8902                                 }
8903                         }
8904                         intStringLen := int(stringLen)
8905                         if intStringLen < 0 {
8906                                 return ErrInvalidLengthGenerated
8907                         }
8908                         postIndex := iNdEx + intStringLen
8909                         if postIndex > l {
8910                                 return io.ErrUnexpectedEOF
8911                         }
8912                         s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex])
8913                         m.Protocol = &s
8914                         iNdEx = postIndex
8915                 case 2:
8916                         if wireType != 2 {
8917                                 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
8918                         }
8919                         var msglen int
8920                         for shift := uint(0); ; shift += 7 {
8921                                 if shift >= 64 {
8922                                         return ErrIntOverflowGenerated
8923                                 }
8924                                 if iNdEx >= l {
8925                                         return io.ErrUnexpectedEOF
8926                                 }
8927                                 b := dAtA[iNdEx]
8928                                 iNdEx++
8929                                 msglen |= (int(b) & 0x7F) << shift
8930                                 if b < 0x80 {
8931                                         break
8932                                 }
8933                         }
8934                         if msglen < 0 {
8935                                 return ErrInvalidLengthGenerated
8936                         }
8937                         postIndex := iNdEx + msglen
8938                         if postIndex > l {
8939                                 return io.ErrUnexpectedEOF
8940                         }
8941                         if m.Port == nil {
8942                                 m.Port = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
8943                         }
8944                         if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8945                                 return err
8946                         }
8947                         iNdEx = postIndex
8948                 default:
8949                         iNdEx = preIndex
8950                         skippy, err := skipGenerated(dAtA[iNdEx:])
8951                         if err != nil {
8952                                 return err
8953                         }
8954                         if skippy < 0 {
8955                                 return ErrInvalidLengthGenerated
8956                         }
8957                         if (iNdEx + skippy) > l {
8958                                 return io.ErrUnexpectedEOF
8959                         }
8960                         iNdEx += skippy
8961                 }
8962         }
8963
8964         if iNdEx > l {
8965                 return io.ErrUnexpectedEOF
8966         }
8967         return nil
8968 }
8969 func (m *NetworkPolicySpec) Unmarshal(dAtA []byte) error {
8970         l := len(dAtA)
8971         iNdEx := 0
8972         for iNdEx < l {
8973                 preIndex := iNdEx
8974                 var wire uint64
8975                 for shift := uint(0); ; shift += 7 {
8976                         if shift >= 64 {
8977                                 return ErrIntOverflowGenerated
8978                         }
8979                         if iNdEx >= l {
8980                                 return io.ErrUnexpectedEOF
8981                         }
8982                         b := dAtA[iNdEx]
8983                         iNdEx++
8984                         wire |= (uint64(b) & 0x7F) << shift
8985                         if b < 0x80 {
8986                                 break
8987                         }
8988                 }
8989                 fieldNum := int32(wire >> 3)
8990                 wireType := int(wire & 0x7)
8991                 if wireType == 4 {
8992                         return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group")
8993                 }
8994                 if fieldNum <= 0 {
8995                         return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
8996                 }
8997                 switch fieldNum {
8998                 case 1:
8999                         if wireType != 2 {
9000                                 return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
9001                         }
9002                         var msglen int
9003                         for shift := uint(0); ; shift += 7 {
9004                                 if shift >= 64 {
9005                                         return ErrIntOverflowGenerated
9006                                 }
9007                                 if iNdEx >= l {
9008                                         return io.ErrUnexpectedEOF
9009                                 }
9010                                 b := dAtA[iNdEx]
9011                                 iNdEx++
9012                                 msglen |= (int(b) & 0x7F) << shift
9013                                 if b < 0x80 {
9014                                         break
9015                                 }
9016                         }
9017                         if msglen < 0 {
9018                                 return ErrInvalidLengthGenerated
9019                         }
9020                         postIndex := iNdEx + msglen
9021                         if postIndex > l {
9022                                 return io.ErrUnexpectedEOF
9023                         }
9024                         if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9025                                 return err
9026                         }
9027                         iNdEx = postIndex
9028                 case 2:
9029                         if wireType != 2 {
9030                                 return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
9031                         }
9032                         var msglen int
9033                         for shift := uint(0); ; shift += 7 {
9034                                 if shift >= 64 {
9035                                         return ErrIntOverflowGenerated
9036                                 }
9037                                 if iNdEx >= l {
9038                                         return io.ErrUnexpectedEOF
9039                                 }
9040                                 b := dAtA[iNdEx]
9041                                 iNdEx++
9042                                 msglen |= (int(b) & 0x7F) << shift
9043                                 if b < 0x80 {
9044                                         break
9045                                 }
9046                         }
9047                         if msglen < 0 {
9048                                 return ErrInvalidLengthGenerated
9049                         }
9050                         postIndex := iNdEx + msglen
9051                         if postIndex > l {
9052                                 return io.ErrUnexpectedEOF
9053                         }
9054                         m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{})
9055                         if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9056                                 return err
9057                         }
9058                         iNdEx = postIndex
9059                 case 3:
9060                         if wireType != 2 {
9061                                 return fmt.Errorf("proto: wrong wireType = %d for field Egress", wireType)
9062                         }
9063                         var msglen int
9064                         for shift := uint(0); ; shift += 7 {
9065                                 if shift >= 64 {
9066                                         return ErrIntOverflowGenerated
9067                                 }
9068                                 if iNdEx >= l {
9069                                         return io.ErrUnexpectedEOF
9070                                 }
9071                                 b := dAtA[iNdEx]
9072                                 iNdEx++
9073                                 msglen |= (int(b) & 0x7F) << shift
9074                                 if b < 0x80 {
9075                                         break
9076                                 }
9077                         }
9078                         if msglen < 0 {
9079                                 return ErrInvalidLengthGenerated
9080                         }
9081                         postIndex := iNdEx + msglen
9082                         if postIndex > l {
9083                                 return io.ErrUnexpectedEOF
9084                         }
9085                         m.Egress = append(m.Egress, NetworkPolicyEgressRule{})
9086                         if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9087                                 return err
9088                         }
9089                         iNdEx = postIndex
9090                 case 4:
9091                         if wireType != 2 {
9092                                 return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", wireType)
9093                         }
9094                         var stringLen uint64
9095                         for shift := uint(0); ; shift += 7 {
9096                                 if shift >= 64 {
9097                                         return ErrIntOverflowGenerated
9098                                 }
9099                                 if iNdEx >= l {
9100                                         return io.ErrUnexpectedEOF
9101                                 }
9102                                 b := dAtA[iNdEx]
9103                                 iNdEx++
9104                                 stringLen |= (uint64(b) & 0x7F) << shift
9105                                 if b < 0x80 {
9106                                         break
9107                                 }
9108                         }
9109                         intStringLen := int(stringLen)
9110                         if intStringLen < 0 {
9111                                 return ErrInvalidLengthGenerated
9112                         }
9113                         postIndex := iNdEx + intStringLen
9114                         if postIndex > l {
9115                                 return io.ErrUnexpectedEOF
9116                         }
9117                         m.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex]))
9118                         iNdEx = postIndex
9119                 default:
9120                         iNdEx = preIndex
9121                         skippy, err := skipGenerated(dAtA[iNdEx:])
9122                         if err != nil {
9123                                 return err
9124                         }
9125                         if skippy < 0 {
9126                                 return ErrInvalidLengthGenerated
9127                         }
9128                         if (iNdEx + skippy) > l {
9129                                 return io.ErrUnexpectedEOF
9130                         }
9131                         iNdEx += skippy
9132                 }
9133         }
9134
9135         if iNdEx > l {
9136                 return io.ErrUnexpectedEOF
9137         }
9138         return nil
9139 }
9140 func (m *PodSecurityPolicy) Unmarshal(dAtA []byte) error {
9141         l := len(dAtA)
9142         iNdEx := 0
9143         for iNdEx < l {
9144                 preIndex := iNdEx
9145                 var wire uint64
9146                 for shift := uint(0); ; shift += 7 {
9147                         if shift >= 64 {
9148                                 return ErrIntOverflowGenerated
9149                         }
9150                         if iNdEx >= l {
9151                                 return io.ErrUnexpectedEOF
9152                         }
9153                         b := dAtA[iNdEx]
9154                         iNdEx++
9155                         wire |= (uint64(b) & 0x7F) << shift
9156                         if b < 0x80 {
9157                                 break
9158                         }
9159                 }
9160                 fieldNum := int32(wire >> 3)
9161                 wireType := int(wire & 0x7)
9162                 if wireType == 4 {
9163                         return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group")
9164                 }
9165                 if fieldNum <= 0 {
9166                         return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
9167                 }
9168                 switch fieldNum {
9169                 case 1:
9170                         if wireType != 2 {
9171                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
9172                         }
9173                         var msglen int
9174                         for shift := uint(0); ; shift += 7 {
9175                                 if shift >= 64 {
9176                                         return ErrIntOverflowGenerated
9177                                 }
9178                                 if iNdEx >= l {
9179                                         return io.ErrUnexpectedEOF
9180                                 }
9181                                 b := dAtA[iNdEx]
9182                                 iNdEx++
9183                                 msglen |= (int(b) & 0x7F) << shift
9184                                 if b < 0x80 {
9185                                         break
9186                                 }
9187                         }
9188                         if msglen < 0 {
9189                                 return ErrInvalidLengthGenerated
9190                         }
9191                         postIndex := iNdEx + msglen
9192                         if postIndex > l {
9193                                 return io.ErrUnexpectedEOF
9194                         }
9195                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9196                                 return err
9197                         }
9198                         iNdEx = postIndex
9199                 case 2:
9200                         if wireType != 2 {
9201                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
9202                         }
9203                         var msglen int
9204                         for shift := uint(0); ; shift += 7 {
9205                                 if shift >= 64 {
9206                                         return ErrIntOverflowGenerated
9207                                 }
9208                                 if iNdEx >= l {
9209                                         return io.ErrUnexpectedEOF
9210                                 }
9211                                 b := dAtA[iNdEx]
9212                                 iNdEx++
9213                                 msglen |= (int(b) & 0x7F) << shift
9214                                 if b < 0x80 {
9215                                         break
9216                                 }
9217                         }
9218                         if msglen < 0 {
9219                                 return ErrInvalidLengthGenerated
9220                         }
9221                         postIndex := iNdEx + msglen
9222                         if postIndex > l {
9223                                 return io.ErrUnexpectedEOF
9224                         }
9225                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9226                                 return err
9227                         }
9228                         iNdEx = postIndex
9229                 default:
9230                         iNdEx = preIndex
9231                         skippy, err := skipGenerated(dAtA[iNdEx:])
9232                         if err != nil {
9233                                 return err
9234                         }
9235                         if skippy < 0 {
9236                                 return ErrInvalidLengthGenerated
9237                         }
9238                         if (iNdEx + skippy) > l {
9239                                 return io.ErrUnexpectedEOF
9240                         }
9241                         iNdEx += skippy
9242                 }
9243         }
9244
9245         if iNdEx > l {
9246                 return io.ErrUnexpectedEOF
9247         }
9248         return nil
9249 }
9250 func (m *PodSecurityPolicyList) Unmarshal(dAtA []byte) error {
9251         l := len(dAtA)
9252         iNdEx := 0
9253         for iNdEx < l {
9254                 preIndex := iNdEx
9255                 var wire uint64
9256                 for shift := uint(0); ; shift += 7 {
9257                         if shift >= 64 {
9258                                 return ErrIntOverflowGenerated
9259                         }
9260                         if iNdEx >= l {
9261                                 return io.ErrUnexpectedEOF
9262                         }
9263                         b := dAtA[iNdEx]
9264                         iNdEx++
9265                         wire |= (uint64(b) & 0x7F) << shift
9266                         if b < 0x80 {
9267                                 break
9268                         }
9269                 }
9270                 fieldNum := int32(wire >> 3)
9271                 wireType := int(wire & 0x7)
9272                 if wireType == 4 {
9273                         return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group")
9274                 }
9275                 if fieldNum <= 0 {
9276                         return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
9277                 }
9278                 switch fieldNum {
9279                 case 1:
9280                         if wireType != 2 {
9281                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
9282                         }
9283                         var msglen int
9284                         for shift := uint(0); ; shift += 7 {
9285                                 if shift >= 64 {
9286                                         return ErrIntOverflowGenerated
9287                                 }
9288                                 if iNdEx >= l {
9289                                         return io.ErrUnexpectedEOF
9290                                 }
9291                                 b := dAtA[iNdEx]
9292                                 iNdEx++
9293                                 msglen |= (int(b) & 0x7F) << shift
9294                                 if b < 0x80 {
9295                                         break
9296                                 }
9297                         }
9298                         if msglen < 0 {
9299                                 return ErrInvalidLengthGenerated
9300                         }
9301                         postIndex := iNdEx + msglen
9302                         if postIndex > l {
9303                                 return io.ErrUnexpectedEOF
9304                         }
9305                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9306                                 return err
9307                         }
9308                         iNdEx = postIndex
9309                 case 2:
9310                         if wireType != 2 {
9311                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
9312                         }
9313                         var msglen int
9314                         for shift := uint(0); ; shift += 7 {
9315                                 if shift >= 64 {
9316                                         return ErrIntOverflowGenerated
9317                                 }
9318                                 if iNdEx >= l {
9319                                         return io.ErrUnexpectedEOF
9320                                 }
9321                                 b := dAtA[iNdEx]
9322                                 iNdEx++
9323                                 msglen |= (int(b) & 0x7F) << shift
9324                                 if b < 0x80 {
9325                                         break
9326                                 }
9327                         }
9328                         if msglen < 0 {
9329                                 return ErrInvalidLengthGenerated
9330                         }
9331                         postIndex := iNdEx + msglen
9332                         if postIndex > l {
9333                                 return io.ErrUnexpectedEOF
9334                         }
9335                         m.Items = append(m.Items, PodSecurityPolicy{})
9336                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9337                                 return err
9338                         }
9339                         iNdEx = postIndex
9340                 default:
9341                         iNdEx = preIndex
9342                         skippy, err := skipGenerated(dAtA[iNdEx:])
9343                         if err != nil {
9344                                 return err
9345                         }
9346                         if skippy < 0 {
9347                                 return ErrInvalidLengthGenerated
9348                         }
9349                         if (iNdEx + skippy) > l {
9350                                 return io.ErrUnexpectedEOF
9351                         }
9352                         iNdEx += skippy
9353                 }
9354         }
9355
9356         if iNdEx > l {
9357                 return io.ErrUnexpectedEOF
9358         }
9359         return nil
9360 }
9361 func (m *PodSecurityPolicySpec) Unmarshal(dAtA []byte) error {
9362         l := len(dAtA)
9363         iNdEx := 0
9364         for iNdEx < l {
9365                 preIndex := iNdEx
9366                 var wire uint64
9367                 for shift := uint(0); ; shift += 7 {
9368                         if shift >= 64 {
9369                                 return ErrIntOverflowGenerated
9370                         }
9371                         if iNdEx >= l {
9372                                 return io.ErrUnexpectedEOF
9373                         }
9374                         b := dAtA[iNdEx]
9375                         iNdEx++
9376                         wire |= (uint64(b) & 0x7F) << shift
9377                         if b < 0x80 {
9378                                 break
9379                         }
9380                 }
9381                 fieldNum := int32(wire >> 3)
9382                 wireType := int(wire & 0x7)
9383                 if wireType == 4 {
9384                         return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group")
9385                 }
9386                 if fieldNum <= 0 {
9387                         return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
9388                 }
9389                 switch fieldNum {
9390                 case 1:
9391                         if wireType != 0 {
9392                                 return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
9393                         }
9394                         var v int
9395                         for shift := uint(0); ; shift += 7 {
9396                                 if shift >= 64 {
9397                                         return ErrIntOverflowGenerated
9398                                 }
9399                                 if iNdEx >= l {
9400                                         return io.ErrUnexpectedEOF
9401                                 }
9402                                 b := dAtA[iNdEx]
9403                                 iNdEx++
9404                                 v |= (int(b) & 0x7F) << shift
9405                                 if b < 0x80 {
9406                                         break
9407                                 }
9408                         }
9409                         m.Privileged = bool(v != 0)
9410                 case 2:
9411                         if wireType != 2 {
9412                                 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType)
9413                         }
9414                         var stringLen uint64
9415                         for shift := uint(0); ; shift += 7 {
9416                                 if shift >= 64 {
9417                                         return ErrIntOverflowGenerated
9418                                 }
9419                                 if iNdEx >= l {
9420                                         return io.ErrUnexpectedEOF
9421                                 }
9422                                 b := dAtA[iNdEx]
9423                                 iNdEx++
9424                                 stringLen |= (uint64(b) & 0x7F) << shift
9425                                 if b < 0x80 {
9426                                         break
9427                                 }
9428                         }
9429                         intStringLen := int(stringLen)
9430                         if intStringLen < 0 {
9431                                 return ErrInvalidLengthGenerated
9432                         }
9433                         postIndex := iNdEx + intStringLen
9434                         if postIndex > l {
9435                                 return io.ErrUnexpectedEOF
9436                         }
9437                         m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9438                         iNdEx = postIndex
9439                 case 3:
9440                         if wireType != 2 {
9441                                 return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType)
9442                         }
9443                         var stringLen uint64
9444                         for shift := uint(0); ; shift += 7 {
9445                                 if shift >= 64 {
9446                                         return ErrIntOverflowGenerated
9447                                 }
9448                                 if iNdEx >= l {
9449                                         return io.ErrUnexpectedEOF
9450                                 }
9451                                 b := dAtA[iNdEx]
9452                                 iNdEx++
9453                                 stringLen |= (uint64(b) & 0x7F) << shift
9454                                 if b < 0x80 {
9455                                         break
9456                                 }
9457                         }
9458                         intStringLen := int(stringLen)
9459                         if intStringLen < 0 {
9460                                 return ErrInvalidLengthGenerated
9461                         }
9462                         postIndex := iNdEx + intStringLen
9463                         if postIndex > l {
9464                                 return io.ErrUnexpectedEOF
9465                         }
9466                         m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9467                         iNdEx = postIndex
9468                 case 4:
9469                         if wireType != 2 {
9470                                 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType)
9471                         }
9472                         var stringLen uint64
9473                         for shift := uint(0); ; shift += 7 {
9474                                 if shift >= 64 {
9475                                         return ErrIntOverflowGenerated
9476                                 }
9477                                 if iNdEx >= l {
9478                                         return io.ErrUnexpectedEOF
9479                                 }
9480                                 b := dAtA[iNdEx]
9481                                 iNdEx++
9482                                 stringLen |= (uint64(b) & 0x7F) << shift
9483                                 if b < 0x80 {
9484                                         break
9485                                 }
9486                         }
9487                         intStringLen := int(stringLen)
9488                         if intStringLen < 0 {
9489                                 return ErrInvalidLengthGenerated
9490                         }
9491                         postIndex := iNdEx + intStringLen
9492                         if postIndex > l {
9493                                 return io.ErrUnexpectedEOF
9494                         }
9495                         m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9496                         iNdEx = postIndex
9497                 case 5:
9498                         if wireType != 2 {
9499                                 return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
9500                         }
9501                         var stringLen uint64
9502                         for shift := uint(0); ; shift += 7 {
9503                                 if shift >= 64 {
9504                                         return ErrIntOverflowGenerated
9505                                 }
9506                                 if iNdEx >= l {
9507                                         return io.ErrUnexpectedEOF
9508                                 }
9509                                 b := dAtA[iNdEx]
9510                                 iNdEx++
9511                                 stringLen |= (uint64(b) & 0x7F) << shift
9512                                 if b < 0x80 {
9513                                         break
9514                                 }
9515                         }
9516                         intStringLen := int(stringLen)
9517                         if intStringLen < 0 {
9518                                 return ErrInvalidLengthGenerated
9519                         }
9520                         postIndex := iNdEx + intStringLen
9521                         if postIndex > l {
9522                                 return io.ErrUnexpectedEOF
9523                         }
9524                         m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex]))
9525                         iNdEx = postIndex
9526                 case 6:
9527                         if wireType != 0 {
9528                                 return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
9529                         }
9530                         var v int
9531                         for shift := uint(0); ; shift += 7 {
9532                                 if shift >= 64 {
9533                                         return ErrIntOverflowGenerated
9534                                 }
9535                                 if iNdEx >= l {
9536                                         return io.ErrUnexpectedEOF
9537                                 }
9538                                 b := dAtA[iNdEx]
9539                                 iNdEx++
9540                                 v |= (int(b) & 0x7F) << shift
9541                                 if b < 0x80 {
9542                                         break
9543                                 }
9544                         }
9545                         m.HostNetwork = bool(v != 0)
9546                 case 7:
9547                         if wireType != 2 {
9548                                 return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType)
9549                         }
9550                         var msglen int
9551                         for shift := uint(0); ; shift += 7 {
9552                                 if shift >= 64 {
9553                                         return ErrIntOverflowGenerated
9554                                 }
9555                                 if iNdEx >= l {
9556                                         return io.ErrUnexpectedEOF
9557                                 }
9558                                 b := dAtA[iNdEx]
9559                                 iNdEx++
9560                                 msglen |= (int(b) & 0x7F) << shift
9561                                 if b < 0x80 {
9562                                         break
9563                                 }
9564                         }
9565                         if msglen < 0 {
9566                                 return ErrInvalidLengthGenerated
9567                         }
9568                         postIndex := iNdEx + msglen
9569                         if postIndex > l {
9570                                 return io.ErrUnexpectedEOF
9571                         }
9572                         m.HostPorts = append(m.HostPorts, HostPortRange{})
9573                         if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9574                                 return err
9575                         }
9576                         iNdEx = postIndex
9577                 case 8:
9578                         if wireType != 0 {
9579                                 return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
9580                         }
9581                         var v int
9582                         for shift := uint(0); ; shift += 7 {
9583                                 if shift >= 64 {
9584                                         return ErrIntOverflowGenerated
9585                                 }
9586                                 if iNdEx >= l {
9587                                         return io.ErrUnexpectedEOF
9588                                 }
9589                                 b := dAtA[iNdEx]
9590                                 iNdEx++
9591                                 v |= (int(b) & 0x7F) << shift
9592                                 if b < 0x80 {
9593                                         break
9594                                 }
9595                         }
9596                         m.HostPID = bool(v != 0)
9597                 case 9:
9598                         if wireType != 0 {
9599                                 return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
9600                         }
9601                         var v int
9602                         for shift := uint(0); ; shift += 7 {
9603                                 if shift >= 64 {
9604                                         return ErrIntOverflowGenerated
9605                                 }
9606                                 if iNdEx >= l {
9607                                         return io.ErrUnexpectedEOF
9608                                 }
9609                                 b := dAtA[iNdEx]
9610                                 iNdEx++
9611                                 v |= (int(b) & 0x7F) << shift
9612                                 if b < 0x80 {
9613                                         break
9614                                 }
9615                         }
9616                         m.HostIPC = bool(v != 0)
9617                 case 10:
9618                         if wireType != 2 {
9619                                 return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType)
9620                         }
9621                         var msglen int
9622                         for shift := uint(0); ; shift += 7 {
9623                                 if shift >= 64 {
9624                                         return ErrIntOverflowGenerated
9625                                 }
9626                                 if iNdEx >= l {
9627                                         return io.ErrUnexpectedEOF
9628                                 }
9629                                 b := dAtA[iNdEx]
9630                                 iNdEx++
9631                                 msglen |= (int(b) & 0x7F) << shift
9632                                 if b < 0x80 {
9633                                         break
9634                                 }
9635                         }
9636                         if msglen < 0 {
9637                                 return ErrInvalidLengthGenerated
9638                         }
9639                         postIndex := iNdEx + msglen
9640                         if postIndex > l {
9641                                 return io.ErrUnexpectedEOF
9642                         }
9643                         if err := m.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9644                                 return err
9645                         }
9646                         iNdEx = postIndex
9647                 case 11:
9648                         if wireType != 2 {
9649                                 return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
9650                         }
9651                         var msglen int
9652                         for shift := uint(0); ; shift += 7 {
9653                                 if shift >= 64 {
9654                                         return ErrIntOverflowGenerated
9655                                 }
9656                                 if iNdEx >= l {
9657                                         return io.ErrUnexpectedEOF
9658                                 }
9659                                 b := dAtA[iNdEx]
9660                                 iNdEx++
9661                                 msglen |= (int(b) & 0x7F) << shift
9662                                 if b < 0x80 {
9663                                         break
9664                                 }
9665                         }
9666                         if msglen < 0 {
9667                                 return ErrInvalidLengthGenerated
9668                         }
9669                         postIndex := iNdEx + msglen
9670                         if postIndex > l {
9671                                 return io.ErrUnexpectedEOF
9672                         }
9673                         if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9674                                 return err
9675                         }
9676                         iNdEx = postIndex
9677                 case 12:
9678                         if wireType != 2 {
9679                                 return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
9680                         }
9681                         var msglen int
9682                         for shift := uint(0); ; shift += 7 {
9683                                 if shift >= 64 {
9684                                         return ErrIntOverflowGenerated
9685                                 }
9686                                 if iNdEx >= l {
9687                                         return io.ErrUnexpectedEOF
9688                                 }
9689                                 b := dAtA[iNdEx]
9690                                 iNdEx++
9691                                 msglen |= (int(b) & 0x7F) << shift
9692                                 if b < 0x80 {
9693                                         break
9694                                 }
9695                         }
9696                         if msglen < 0 {
9697                                 return ErrInvalidLengthGenerated
9698                         }
9699                         postIndex := iNdEx + msglen
9700                         if postIndex > l {
9701                                 return io.ErrUnexpectedEOF
9702                         }
9703                         if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9704                                 return err
9705                         }
9706                         iNdEx = postIndex
9707                 case 13:
9708                         if wireType != 2 {
9709                                 return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
9710                         }
9711                         var msglen int
9712                         for shift := uint(0); ; shift += 7 {
9713                                 if shift >= 64 {
9714                                         return ErrIntOverflowGenerated
9715                                 }
9716                                 if iNdEx >= l {
9717                                         return io.ErrUnexpectedEOF
9718                                 }
9719                                 b := dAtA[iNdEx]
9720                                 iNdEx++
9721                                 msglen |= (int(b) & 0x7F) << shift
9722                                 if b < 0x80 {
9723                                         break
9724                                 }
9725                         }
9726                         if msglen < 0 {
9727                                 return ErrInvalidLengthGenerated
9728                         }
9729                         postIndex := iNdEx + msglen
9730                         if postIndex > l {
9731                                 return io.ErrUnexpectedEOF
9732                         }
9733                         if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9734                                 return err
9735                         }
9736                         iNdEx = postIndex
9737                 case 14:
9738                         if wireType != 0 {
9739                                 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
9740                         }
9741                         var v int
9742                         for shift := uint(0); ; shift += 7 {
9743                                 if shift >= 64 {
9744                                         return ErrIntOverflowGenerated
9745                                 }
9746                                 if iNdEx >= l {
9747                                         return io.ErrUnexpectedEOF
9748                                 }
9749                                 b := dAtA[iNdEx]
9750                                 iNdEx++
9751                                 v |= (int(b) & 0x7F) << shift
9752                                 if b < 0x80 {
9753                                         break
9754                                 }
9755                         }
9756                         m.ReadOnlyRootFilesystem = bool(v != 0)
9757                 case 15:
9758                         if wireType != 0 {
9759                                 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType)
9760                         }
9761                         var v int
9762                         for shift := uint(0); ; shift += 7 {
9763                                 if shift >= 64 {
9764                                         return ErrIntOverflowGenerated
9765                                 }
9766                                 if iNdEx >= l {
9767                                         return io.ErrUnexpectedEOF
9768                                 }
9769                                 b := dAtA[iNdEx]
9770                                 iNdEx++
9771                                 v |= (int(b) & 0x7F) << shift
9772                                 if b < 0x80 {
9773                                         break
9774                                 }
9775                         }
9776                         b := bool(v != 0)
9777                         m.DefaultAllowPrivilegeEscalation = &b
9778                 case 16:
9779                         if wireType != 0 {
9780                                 return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType)
9781                         }
9782                         var v int
9783                         for shift := uint(0); ; shift += 7 {
9784                                 if shift >= 64 {
9785                                         return ErrIntOverflowGenerated
9786                                 }
9787                                 if iNdEx >= l {
9788                                         return io.ErrUnexpectedEOF
9789                                 }
9790                                 b := dAtA[iNdEx]
9791                                 iNdEx++
9792                                 v |= (int(b) & 0x7F) << shift
9793                                 if b < 0x80 {
9794                                         break
9795                                 }
9796                         }
9797                         b := bool(v != 0)
9798                         m.AllowPrivilegeEscalation = &b
9799                 case 17:
9800                         if wireType != 2 {
9801                                 return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", wireType)
9802                         }
9803                         var msglen int
9804                         for shift := uint(0); ; shift += 7 {
9805                                 if shift >= 64 {
9806                                         return ErrIntOverflowGenerated
9807                                 }
9808                                 if iNdEx >= l {
9809                                         return io.ErrUnexpectedEOF
9810                                 }
9811                                 b := dAtA[iNdEx]
9812                                 iNdEx++
9813                                 msglen |= (int(b) & 0x7F) << shift
9814                                 if b < 0x80 {
9815                                         break
9816                                 }
9817                         }
9818                         if msglen < 0 {
9819                                 return ErrInvalidLengthGenerated
9820                         }
9821                         postIndex := iNdEx + msglen
9822                         if postIndex > l {
9823                                 return io.ErrUnexpectedEOF
9824                         }
9825                         m.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{})
9826                         if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9827                                 return err
9828                         }
9829                         iNdEx = postIndex
9830                 case 18:
9831                         if wireType != 2 {
9832                                 return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType)
9833                         }
9834                         var msglen int
9835                         for shift := uint(0); ; shift += 7 {
9836                                 if shift >= 64 {
9837                                         return ErrIntOverflowGenerated
9838                                 }
9839                                 if iNdEx >= l {
9840                                         return io.ErrUnexpectedEOF
9841                                 }
9842                                 b := dAtA[iNdEx]
9843                                 iNdEx++
9844                                 msglen |= (int(b) & 0x7F) << shift
9845                                 if b < 0x80 {
9846                                         break
9847                                 }
9848                         }
9849                         if msglen < 0 {
9850                                 return ErrInvalidLengthGenerated
9851                         }
9852                         postIndex := iNdEx + msglen
9853                         if postIndex > l {
9854                                 return io.ErrUnexpectedEOF
9855                         }
9856                         m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{})
9857                         if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9858                                 return err
9859                         }
9860                         iNdEx = postIndex
9861                 case 19:
9862                         if wireType != 2 {
9863                                 return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType)
9864                         }
9865                         var stringLen uint64
9866                         for shift := uint(0); ; shift += 7 {
9867                                 if shift >= 64 {
9868                                         return ErrIntOverflowGenerated
9869                                 }
9870                                 if iNdEx >= l {
9871                                         return io.ErrUnexpectedEOF
9872                                 }
9873                                 b := dAtA[iNdEx]
9874                                 iNdEx++
9875                                 stringLen |= (uint64(b) & 0x7F) << shift
9876                                 if b < 0x80 {
9877                                         break
9878                                 }
9879                         }
9880                         intStringLen := int(stringLen)
9881                         if intStringLen < 0 {
9882                                 return ErrInvalidLengthGenerated
9883                         }
9884                         postIndex := iNdEx + intStringLen
9885                         if postIndex > l {
9886                                 return io.ErrUnexpectedEOF
9887                         }
9888                         m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex]))
9889                         iNdEx = postIndex
9890                 case 20:
9891                         if wireType != 2 {
9892                                 return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType)
9893                         }
9894                         var stringLen uint64
9895                         for shift := uint(0); ; shift += 7 {
9896                                 if shift >= 64 {
9897                                         return ErrIntOverflowGenerated
9898                                 }
9899                                 if iNdEx >= l {
9900                                         return io.ErrUnexpectedEOF
9901                                 }
9902                                 b := dAtA[iNdEx]
9903                                 iNdEx++
9904                                 stringLen |= (uint64(b) & 0x7F) << shift
9905                                 if b < 0x80 {
9906                                         break
9907                                 }
9908                         }
9909                         intStringLen := int(stringLen)
9910                         if intStringLen < 0 {
9911                                 return ErrInvalidLengthGenerated
9912                         }
9913                         postIndex := iNdEx + intStringLen
9914                         if postIndex > l {
9915                                 return io.ErrUnexpectedEOF
9916                         }
9917                         m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex]))
9918                         iNdEx = postIndex
9919                 case 21:
9920                         if wireType != 2 {
9921                                 return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", wireType)
9922                         }
9923                         var stringLen uint64
9924                         for shift := uint(0); ; shift += 7 {
9925                                 if shift >= 64 {
9926                                         return ErrIntOverflowGenerated
9927                                 }
9928                                 if iNdEx >= l {
9929                                         return io.ErrUnexpectedEOF
9930                                 }
9931                                 b := dAtA[iNdEx]
9932                                 iNdEx++
9933                                 stringLen |= (uint64(b) & 0x7F) << shift
9934                                 if b < 0x80 {
9935                                         break
9936                                 }
9937                         }
9938                         intStringLen := int(stringLen)
9939                         if intStringLen < 0 {
9940                                 return ErrInvalidLengthGenerated
9941                         }
9942                         postIndex := iNdEx + intStringLen
9943                         if postIndex > l {
9944                                 return io.ErrUnexpectedEOF
9945                         }
9946                         m.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex]))
9947                         iNdEx = postIndex
9948                 case 22:
9949                         if wireType != 2 {
9950                                 return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", wireType)
9951                         }
9952                         var msglen int
9953                         for shift := uint(0); ; shift += 7 {
9954                                 if shift >= 64 {
9955                                         return ErrIntOverflowGenerated
9956                                 }
9957                                 if iNdEx >= l {
9958                                         return io.ErrUnexpectedEOF
9959                                 }
9960                                 b := dAtA[iNdEx]
9961                                 iNdEx++
9962                                 msglen |= (int(b) & 0x7F) << shift
9963                                 if b < 0x80 {
9964                                         break
9965                                 }
9966                         }
9967                         if msglen < 0 {
9968                                 return ErrInvalidLengthGenerated
9969                         }
9970                         postIndex := iNdEx + msglen
9971                         if postIndex > l {
9972                                 return io.ErrUnexpectedEOF
9973                         }
9974                         if m.RunAsGroup == nil {
9975                                 m.RunAsGroup = &RunAsGroupStrategyOptions{}
9976                         }
9977                         if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9978                                 return err
9979                         }
9980                         iNdEx = postIndex
9981                 default:
9982                         iNdEx = preIndex
9983                         skippy, err := skipGenerated(dAtA[iNdEx:])
9984                         if err != nil {
9985                                 return err
9986                         }
9987                         if skippy < 0 {
9988                                 return ErrInvalidLengthGenerated
9989                         }
9990                         if (iNdEx + skippy) > l {
9991                                 return io.ErrUnexpectedEOF
9992                         }
9993                         iNdEx += skippy
9994                 }
9995         }
9996
9997         if iNdEx > l {
9998                 return io.ErrUnexpectedEOF
9999         }
10000         return nil
10001 }
10002 func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
10003         l := len(dAtA)
10004         iNdEx := 0
10005         for iNdEx < l {
10006                 preIndex := iNdEx
10007                 var wire uint64
10008                 for shift := uint(0); ; shift += 7 {
10009                         if shift >= 64 {
10010                                 return ErrIntOverflowGenerated
10011                         }
10012                         if iNdEx >= l {
10013                                 return io.ErrUnexpectedEOF
10014                         }
10015                         b := dAtA[iNdEx]
10016                         iNdEx++
10017                         wire |= (uint64(b) & 0x7F) << shift
10018                         if b < 0x80 {
10019                                 break
10020                         }
10021                 }
10022                 fieldNum := int32(wire >> 3)
10023                 wireType := int(wire & 0x7)
10024                 if wireType == 4 {
10025                         return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
10026                 }
10027                 if fieldNum <= 0 {
10028                         return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
10029                 }
10030                 switch fieldNum {
10031                 case 1:
10032                         if wireType != 2 {
10033                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
10034                         }
10035                         var msglen int
10036                         for shift := uint(0); ; shift += 7 {
10037                                 if shift >= 64 {
10038                                         return ErrIntOverflowGenerated
10039                                 }
10040                                 if iNdEx >= l {
10041                                         return io.ErrUnexpectedEOF
10042                                 }
10043                                 b := dAtA[iNdEx]
10044                                 iNdEx++
10045                                 msglen |= (int(b) & 0x7F) << shift
10046                                 if b < 0x80 {
10047                                         break
10048                                 }
10049                         }
10050                         if msglen < 0 {
10051                                 return ErrInvalidLengthGenerated
10052                         }
10053                         postIndex := iNdEx + msglen
10054                         if postIndex > l {
10055                                 return io.ErrUnexpectedEOF
10056                         }
10057                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10058                                 return err
10059                         }
10060                         iNdEx = postIndex
10061                 case 2:
10062                         if wireType != 2 {
10063                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
10064                         }
10065                         var msglen int
10066                         for shift := uint(0); ; shift += 7 {
10067                                 if shift >= 64 {
10068                                         return ErrIntOverflowGenerated
10069                                 }
10070                                 if iNdEx >= l {
10071                                         return io.ErrUnexpectedEOF
10072                                 }
10073                                 b := dAtA[iNdEx]
10074                                 iNdEx++
10075                                 msglen |= (int(b) & 0x7F) << shift
10076                                 if b < 0x80 {
10077                                         break
10078                                 }
10079                         }
10080                         if msglen < 0 {
10081                                 return ErrInvalidLengthGenerated
10082                         }
10083                         postIndex := iNdEx + msglen
10084                         if postIndex > l {
10085                                 return io.ErrUnexpectedEOF
10086                         }
10087                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10088                                 return err
10089                         }
10090                         iNdEx = postIndex
10091                 case 3:
10092                         if wireType != 2 {
10093                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
10094                         }
10095                         var msglen int
10096                         for shift := uint(0); ; shift += 7 {
10097                                 if shift >= 64 {
10098                                         return ErrIntOverflowGenerated
10099                                 }
10100                                 if iNdEx >= l {
10101                                         return io.ErrUnexpectedEOF
10102                                 }
10103                                 b := dAtA[iNdEx]
10104                                 iNdEx++
10105                                 msglen |= (int(b) & 0x7F) << shift
10106                                 if b < 0x80 {
10107                                         break
10108                                 }
10109                         }
10110                         if msglen < 0 {
10111                                 return ErrInvalidLengthGenerated
10112                         }
10113                         postIndex := iNdEx + msglen
10114                         if postIndex > l {
10115                                 return io.ErrUnexpectedEOF
10116                         }
10117                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10118                                 return err
10119                         }
10120                         iNdEx = postIndex
10121                 default:
10122                         iNdEx = preIndex
10123                         skippy, err := skipGenerated(dAtA[iNdEx:])
10124                         if err != nil {
10125                                 return err
10126                         }
10127                         if skippy < 0 {
10128                                 return ErrInvalidLengthGenerated
10129                         }
10130                         if (iNdEx + skippy) > l {
10131                                 return io.ErrUnexpectedEOF
10132                         }
10133                         iNdEx += skippy
10134                 }
10135         }
10136
10137         if iNdEx > l {
10138                 return io.ErrUnexpectedEOF
10139         }
10140         return nil
10141 }
10142 func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
10143         l := len(dAtA)
10144         iNdEx := 0
10145         for iNdEx < l {
10146                 preIndex := iNdEx
10147                 var wire uint64
10148                 for shift := uint(0); ; shift += 7 {
10149                         if shift >= 64 {
10150                                 return ErrIntOverflowGenerated
10151                         }
10152                         if iNdEx >= l {
10153                                 return io.ErrUnexpectedEOF
10154                         }
10155                         b := dAtA[iNdEx]
10156                         iNdEx++
10157                         wire |= (uint64(b) & 0x7F) << shift
10158                         if b < 0x80 {
10159                                 break
10160                         }
10161                 }
10162                 fieldNum := int32(wire >> 3)
10163                 wireType := int(wire & 0x7)
10164                 if wireType == 4 {
10165                         return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
10166                 }
10167                 if fieldNum <= 0 {
10168                         return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
10169                 }
10170                 switch fieldNum {
10171                 case 1:
10172                         if wireType != 2 {
10173                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
10174                         }
10175                         var stringLen uint64
10176                         for shift := uint(0); ; shift += 7 {
10177                                 if shift >= 64 {
10178                                         return ErrIntOverflowGenerated
10179                                 }
10180                                 if iNdEx >= l {
10181                                         return io.ErrUnexpectedEOF
10182                                 }
10183                                 b := dAtA[iNdEx]
10184                                 iNdEx++
10185                                 stringLen |= (uint64(b) & 0x7F) << shift
10186                                 if b < 0x80 {
10187                                         break
10188                                 }
10189                         }
10190                         intStringLen := int(stringLen)
10191                         if intStringLen < 0 {
10192                                 return ErrInvalidLengthGenerated
10193                         }
10194                         postIndex := iNdEx + intStringLen
10195                         if postIndex > l {
10196                                 return io.ErrUnexpectedEOF
10197                         }
10198                         m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex])
10199                         iNdEx = postIndex
10200                 case 2:
10201                         if wireType != 2 {
10202                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
10203                         }
10204                         var stringLen uint64
10205                         for shift := uint(0); ; shift += 7 {
10206                                 if shift >= 64 {
10207                                         return ErrIntOverflowGenerated
10208                                 }
10209                                 if iNdEx >= l {
10210                                         return io.ErrUnexpectedEOF
10211                                 }
10212                                 b := dAtA[iNdEx]
10213                                 iNdEx++
10214                                 stringLen |= (uint64(b) & 0x7F) << shift
10215                                 if b < 0x80 {
10216                                         break
10217                                 }
10218                         }
10219                         intStringLen := int(stringLen)
10220                         if intStringLen < 0 {
10221                                 return ErrInvalidLengthGenerated
10222                         }
10223                         postIndex := iNdEx + intStringLen
10224                         if postIndex > l {
10225                                 return io.ErrUnexpectedEOF
10226                         }
10227                         m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
10228                         iNdEx = postIndex
10229                 case 3:
10230                         if wireType != 2 {
10231                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
10232                         }
10233                         var msglen int
10234                         for shift := uint(0); ; shift += 7 {
10235                                 if shift >= 64 {
10236                                         return ErrIntOverflowGenerated
10237                                 }
10238                                 if iNdEx >= l {
10239                                         return io.ErrUnexpectedEOF
10240                                 }
10241                                 b := dAtA[iNdEx]
10242                                 iNdEx++
10243                                 msglen |= (int(b) & 0x7F) << shift
10244                                 if b < 0x80 {
10245                                         break
10246                                 }
10247                         }
10248                         if msglen < 0 {
10249                                 return ErrInvalidLengthGenerated
10250                         }
10251                         postIndex := iNdEx + msglen
10252                         if postIndex > l {
10253                                 return io.ErrUnexpectedEOF
10254                         }
10255                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10256                                 return err
10257                         }
10258                         iNdEx = postIndex
10259                 case 4:
10260                         if wireType != 2 {
10261                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
10262                         }
10263                         var stringLen uint64
10264                         for shift := uint(0); ; shift += 7 {
10265                                 if shift >= 64 {
10266                                         return ErrIntOverflowGenerated
10267                                 }
10268                                 if iNdEx >= l {
10269                                         return io.ErrUnexpectedEOF
10270                                 }
10271                                 b := dAtA[iNdEx]
10272                                 iNdEx++
10273                                 stringLen |= (uint64(b) & 0x7F) << shift
10274                                 if b < 0x80 {
10275                                         break
10276                                 }
10277                         }
10278                         intStringLen := int(stringLen)
10279                         if intStringLen < 0 {
10280                                 return ErrInvalidLengthGenerated
10281                         }
10282                         postIndex := iNdEx + intStringLen
10283                         if postIndex > l {
10284                                 return io.ErrUnexpectedEOF
10285                         }
10286                         m.Reason = string(dAtA[iNdEx:postIndex])
10287                         iNdEx = postIndex
10288                 case 5:
10289                         if wireType != 2 {
10290                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
10291                         }
10292                         var stringLen uint64
10293                         for shift := uint(0); ; shift += 7 {
10294                                 if shift >= 64 {
10295                                         return ErrIntOverflowGenerated
10296                                 }
10297                                 if iNdEx >= l {
10298                                         return io.ErrUnexpectedEOF
10299                                 }
10300                                 b := dAtA[iNdEx]
10301                                 iNdEx++
10302                                 stringLen |= (uint64(b) & 0x7F) << shift
10303                                 if b < 0x80 {
10304                                         break
10305                                 }
10306                         }
10307                         intStringLen := int(stringLen)
10308                         if intStringLen < 0 {
10309                                 return ErrInvalidLengthGenerated
10310                         }
10311                         postIndex := iNdEx + intStringLen
10312                         if postIndex > l {
10313                                 return io.ErrUnexpectedEOF
10314                         }
10315                         m.Message = string(dAtA[iNdEx:postIndex])
10316                         iNdEx = postIndex
10317                 default:
10318                         iNdEx = preIndex
10319                         skippy, err := skipGenerated(dAtA[iNdEx:])
10320                         if err != nil {
10321                                 return err
10322                         }
10323                         if skippy < 0 {
10324                                 return ErrInvalidLengthGenerated
10325                         }
10326                         if (iNdEx + skippy) > l {
10327                                 return io.ErrUnexpectedEOF
10328                         }
10329                         iNdEx += skippy
10330                 }
10331         }
10332
10333         if iNdEx > l {
10334                 return io.ErrUnexpectedEOF
10335         }
10336         return nil
10337 }
10338 func (m *ReplicaSetList) Unmarshal(dAtA []byte) error {
10339         l := len(dAtA)
10340         iNdEx := 0
10341         for iNdEx < l {
10342                 preIndex := iNdEx
10343                 var wire uint64
10344                 for shift := uint(0); ; shift += 7 {
10345                         if shift >= 64 {
10346                                 return ErrIntOverflowGenerated
10347                         }
10348                         if iNdEx >= l {
10349                                 return io.ErrUnexpectedEOF
10350                         }
10351                         b := dAtA[iNdEx]
10352                         iNdEx++
10353                         wire |= (uint64(b) & 0x7F) << shift
10354                         if b < 0x80 {
10355                                 break
10356                         }
10357                 }
10358                 fieldNum := int32(wire >> 3)
10359                 wireType := int(wire & 0x7)
10360                 if wireType == 4 {
10361                         return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
10362                 }
10363                 if fieldNum <= 0 {
10364                         return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
10365                 }
10366                 switch fieldNum {
10367                 case 1:
10368                         if wireType != 2 {
10369                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
10370                         }
10371                         var msglen int
10372                         for shift := uint(0); ; shift += 7 {
10373                                 if shift >= 64 {
10374                                         return ErrIntOverflowGenerated
10375                                 }
10376                                 if iNdEx >= l {
10377                                         return io.ErrUnexpectedEOF
10378                                 }
10379                                 b := dAtA[iNdEx]
10380                                 iNdEx++
10381                                 msglen |= (int(b) & 0x7F) << shift
10382                                 if b < 0x80 {
10383                                         break
10384                                 }
10385                         }
10386                         if msglen < 0 {
10387                                 return ErrInvalidLengthGenerated
10388                         }
10389                         postIndex := iNdEx + msglen
10390                         if postIndex > l {
10391                                 return io.ErrUnexpectedEOF
10392                         }
10393                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10394                                 return err
10395                         }
10396                         iNdEx = postIndex
10397                 case 2:
10398                         if wireType != 2 {
10399                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
10400                         }
10401                         var msglen int
10402                         for shift := uint(0); ; shift += 7 {
10403                                 if shift >= 64 {
10404                                         return ErrIntOverflowGenerated
10405                                 }
10406                                 if iNdEx >= l {
10407                                         return io.ErrUnexpectedEOF
10408                                 }
10409                                 b := dAtA[iNdEx]
10410                                 iNdEx++
10411                                 msglen |= (int(b) & 0x7F) << shift
10412                                 if b < 0x80 {
10413                                         break
10414                                 }
10415                         }
10416                         if msglen < 0 {
10417                                 return ErrInvalidLengthGenerated
10418                         }
10419                         postIndex := iNdEx + msglen
10420                         if postIndex > l {
10421                                 return io.ErrUnexpectedEOF
10422                         }
10423                         m.Items = append(m.Items, ReplicaSet{})
10424                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10425                                 return err
10426                         }
10427                         iNdEx = postIndex
10428                 default:
10429                         iNdEx = preIndex
10430                         skippy, err := skipGenerated(dAtA[iNdEx:])
10431                         if err != nil {
10432                                 return err
10433                         }
10434                         if skippy < 0 {
10435                                 return ErrInvalidLengthGenerated
10436                         }
10437                         if (iNdEx + skippy) > l {
10438                                 return io.ErrUnexpectedEOF
10439                         }
10440                         iNdEx += skippy
10441                 }
10442         }
10443
10444         if iNdEx > l {
10445                 return io.ErrUnexpectedEOF
10446         }
10447         return nil
10448 }
10449 func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
10450         l := len(dAtA)
10451         iNdEx := 0
10452         for iNdEx < l {
10453                 preIndex := iNdEx
10454                 var wire uint64
10455                 for shift := uint(0); ; shift += 7 {
10456                         if shift >= 64 {
10457                                 return ErrIntOverflowGenerated
10458                         }
10459                         if iNdEx >= l {
10460                                 return io.ErrUnexpectedEOF
10461                         }
10462                         b := dAtA[iNdEx]
10463                         iNdEx++
10464                         wire |= (uint64(b) & 0x7F) << shift
10465                         if b < 0x80 {
10466                                 break
10467                         }
10468                 }
10469                 fieldNum := int32(wire >> 3)
10470                 wireType := int(wire & 0x7)
10471                 if wireType == 4 {
10472                         return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
10473                 }
10474                 if fieldNum <= 0 {
10475                         return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
10476                 }
10477                 switch fieldNum {
10478                 case 1:
10479                         if wireType != 0 {
10480                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
10481                         }
10482                         var v int32
10483                         for shift := uint(0); ; shift += 7 {
10484                                 if shift >= 64 {
10485                                         return ErrIntOverflowGenerated
10486                                 }
10487                                 if iNdEx >= l {
10488                                         return io.ErrUnexpectedEOF
10489                                 }
10490                                 b := dAtA[iNdEx]
10491                                 iNdEx++
10492                                 v |= (int32(b) & 0x7F) << shift
10493                                 if b < 0x80 {
10494                                         break
10495                                 }
10496                         }
10497                         m.Replicas = &v
10498                 case 2:
10499                         if wireType != 2 {
10500                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
10501                         }
10502                         var msglen int
10503                         for shift := uint(0); ; shift += 7 {
10504                                 if shift >= 64 {
10505                                         return ErrIntOverflowGenerated
10506                                 }
10507                                 if iNdEx >= l {
10508                                         return io.ErrUnexpectedEOF
10509                                 }
10510                                 b := dAtA[iNdEx]
10511                                 iNdEx++
10512                                 msglen |= (int(b) & 0x7F) << shift
10513                                 if b < 0x80 {
10514                                         break
10515                                 }
10516                         }
10517                         if msglen < 0 {
10518                                 return ErrInvalidLengthGenerated
10519                         }
10520                         postIndex := iNdEx + msglen
10521                         if postIndex > l {
10522                                 return io.ErrUnexpectedEOF
10523                         }
10524                         if m.Selector == nil {
10525                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
10526                         }
10527                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10528                                 return err
10529                         }
10530                         iNdEx = postIndex
10531                 case 3:
10532                         if wireType != 2 {
10533                                 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
10534                         }
10535                         var msglen int
10536                         for shift := uint(0); ; shift += 7 {
10537                                 if shift >= 64 {
10538                                         return ErrIntOverflowGenerated
10539                                 }
10540                                 if iNdEx >= l {
10541                                         return io.ErrUnexpectedEOF
10542                                 }
10543                                 b := dAtA[iNdEx]
10544                                 iNdEx++
10545                                 msglen |= (int(b) & 0x7F) << shift
10546                                 if b < 0x80 {
10547                                         break
10548                                 }
10549                         }
10550                         if msglen < 0 {
10551                                 return ErrInvalidLengthGenerated
10552                         }
10553                         postIndex := iNdEx + msglen
10554                         if postIndex > l {
10555                                 return io.ErrUnexpectedEOF
10556                         }
10557                         if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10558                                 return err
10559                         }
10560                         iNdEx = postIndex
10561                 case 4:
10562                         if wireType != 0 {
10563                                 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
10564                         }
10565                         m.MinReadySeconds = 0
10566                         for shift := uint(0); ; shift += 7 {
10567                                 if shift >= 64 {
10568                                         return ErrIntOverflowGenerated
10569                                 }
10570                                 if iNdEx >= l {
10571                                         return io.ErrUnexpectedEOF
10572                                 }
10573                                 b := dAtA[iNdEx]
10574                                 iNdEx++
10575                                 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
10576                                 if b < 0x80 {
10577                                         break
10578                                 }
10579                         }
10580                 default:
10581                         iNdEx = preIndex
10582                         skippy, err := skipGenerated(dAtA[iNdEx:])
10583                         if err != nil {
10584                                 return err
10585                         }
10586                         if skippy < 0 {
10587                                 return ErrInvalidLengthGenerated
10588                         }
10589                         if (iNdEx + skippy) > l {
10590                                 return io.ErrUnexpectedEOF
10591                         }
10592                         iNdEx += skippy
10593                 }
10594         }
10595
10596         if iNdEx > l {
10597                 return io.ErrUnexpectedEOF
10598         }
10599         return nil
10600 }
10601 func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
10602         l := len(dAtA)
10603         iNdEx := 0
10604         for iNdEx < l {
10605                 preIndex := iNdEx
10606                 var wire uint64
10607                 for shift := uint(0); ; shift += 7 {
10608                         if shift >= 64 {
10609                                 return ErrIntOverflowGenerated
10610                         }
10611                         if iNdEx >= l {
10612                                 return io.ErrUnexpectedEOF
10613                         }
10614                         b := dAtA[iNdEx]
10615                         iNdEx++
10616                         wire |= (uint64(b) & 0x7F) << shift
10617                         if b < 0x80 {
10618                                 break
10619                         }
10620                 }
10621                 fieldNum := int32(wire >> 3)
10622                 wireType := int(wire & 0x7)
10623                 if wireType == 4 {
10624                         return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
10625                 }
10626                 if fieldNum <= 0 {
10627                         return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
10628                 }
10629                 switch fieldNum {
10630                 case 1:
10631                         if wireType != 0 {
10632                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
10633                         }
10634                         m.Replicas = 0
10635                         for shift := uint(0); ; shift += 7 {
10636                                 if shift >= 64 {
10637                                         return ErrIntOverflowGenerated
10638                                 }
10639                                 if iNdEx >= l {
10640                                         return io.ErrUnexpectedEOF
10641                                 }
10642                                 b := dAtA[iNdEx]
10643                                 iNdEx++
10644                                 m.Replicas |= (int32(b) & 0x7F) << shift
10645                                 if b < 0x80 {
10646                                         break
10647                                 }
10648                         }
10649                 case 2:
10650                         if wireType != 0 {
10651                                 return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
10652                         }
10653                         m.FullyLabeledReplicas = 0
10654                         for shift := uint(0); ; shift += 7 {
10655                                 if shift >= 64 {
10656                                         return ErrIntOverflowGenerated
10657                                 }
10658                                 if iNdEx >= l {
10659                                         return io.ErrUnexpectedEOF
10660                                 }
10661                                 b := dAtA[iNdEx]
10662                                 iNdEx++
10663                                 m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift
10664                                 if b < 0x80 {
10665                                         break
10666                                 }
10667                         }
10668                 case 3:
10669                         if wireType != 0 {
10670                                 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
10671                         }
10672                         m.ObservedGeneration = 0
10673                         for shift := uint(0); ; shift += 7 {
10674                                 if shift >= 64 {
10675                                         return ErrIntOverflowGenerated
10676                                 }
10677                                 if iNdEx >= l {
10678                                         return io.ErrUnexpectedEOF
10679                                 }
10680                                 b := dAtA[iNdEx]
10681                                 iNdEx++
10682                                 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
10683                                 if b < 0x80 {
10684                                         break
10685                                 }
10686                         }
10687                 case 4:
10688                         if wireType != 0 {
10689                                 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
10690                         }
10691                         m.ReadyReplicas = 0
10692                         for shift := uint(0); ; shift += 7 {
10693                                 if shift >= 64 {
10694                                         return ErrIntOverflowGenerated
10695                                 }
10696                                 if iNdEx >= l {
10697                                         return io.ErrUnexpectedEOF
10698                                 }
10699                                 b := dAtA[iNdEx]
10700                                 iNdEx++
10701                                 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
10702                                 if b < 0x80 {
10703                                         break
10704                                 }
10705                         }
10706                 case 5:
10707                         if wireType != 0 {
10708                                 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
10709                         }
10710                         m.AvailableReplicas = 0
10711                         for shift := uint(0); ; shift += 7 {
10712                                 if shift >= 64 {
10713                                         return ErrIntOverflowGenerated
10714                                 }
10715                                 if iNdEx >= l {
10716                                         return io.ErrUnexpectedEOF
10717                                 }
10718                                 b := dAtA[iNdEx]
10719                                 iNdEx++
10720                                 m.AvailableReplicas |= (int32(b) & 0x7F) << shift
10721                                 if b < 0x80 {
10722                                         break
10723                                 }
10724                         }
10725                 case 6:
10726                         if wireType != 2 {
10727                                 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
10728                         }
10729                         var msglen int
10730                         for shift := uint(0); ; shift += 7 {
10731                                 if shift >= 64 {
10732                                         return ErrIntOverflowGenerated
10733                                 }
10734                                 if iNdEx >= l {
10735                                         return io.ErrUnexpectedEOF
10736                                 }
10737                                 b := dAtA[iNdEx]
10738                                 iNdEx++
10739                                 msglen |= (int(b) & 0x7F) << shift
10740                                 if b < 0x80 {
10741                                         break
10742                                 }
10743                         }
10744                         if msglen < 0 {
10745                                 return ErrInvalidLengthGenerated
10746                         }
10747                         postIndex := iNdEx + msglen
10748                         if postIndex > l {
10749                                 return io.ErrUnexpectedEOF
10750                         }
10751                         m.Conditions = append(m.Conditions, ReplicaSetCondition{})
10752                         if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10753                                 return err
10754                         }
10755                         iNdEx = postIndex
10756                 default:
10757                         iNdEx = preIndex
10758                         skippy, err := skipGenerated(dAtA[iNdEx:])
10759                         if err != nil {
10760                                 return err
10761                         }
10762                         if skippy < 0 {
10763                                 return ErrInvalidLengthGenerated
10764                         }
10765                         if (iNdEx + skippy) > l {
10766                                 return io.ErrUnexpectedEOF
10767                         }
10768                         iNdEx += skippy
10769                 }
10770         }
10771
10772         if iNdEx > l {
10773                 return io.ErrUnexpectedEOF
10774         }
10775         return nil
10776 }
10777 func (m *ReplicationControllerDummy) Unmarshal(dAtA []byte) error {
10778         l := len(dAtA)
10779         iNdEx := 0
10780         for iNdEx < l {
10781                 preIndex := iNdEx
10782                 var wire uint64
10783                 for shift := uint(0); ; shift += 7 {
10784                         if shift >= 64 {
10785                                 return ErrIntOverflowGenerated
10786                         }
10787                         if iNdEx >= l {
10788                                 return io.ErrUnexpectedEOF
10789                         }
10790                         b := dAtA[iNdEx]
10791                         iNdEx++
10792                         wire |= (uint64(b) & 0x7F) << shift
10793                         if b < 0x80 {
10794                                 break
10795                         }
10796                 }
10797                 fieldNum := int32(wire >> 3)
10798                 wireType := int(wire & 0x7)
10799                 if wireType == 4 {
10800                         return fmt.Errorf("proto: ReplicationControllerDummy: wiretype end group for non-group")
10801                 }
10802                 if fieldNum <= 0 {
10803                         return fmt.Errorf("proto: ReplicationControllerDummy: illegal tag %d (wire type %d)", fieldNum, wire)
10804                 }
10805                 switch fieldNum {
10806                 default:
10807                         iNdEx = preIndex
10808                         skippy, err := skipGenerated(dAtA[iNdEx:])
10809                         if err != nil {
10810                                 return err
10811                         }
10812                         if skippy < 0 {
10813                                 return ErrInvalidLengthGenerated
10814                         }
10815                         if (iNdEx + skippy) > l {
10816                                 return io.ErrUnexpectedEOF
10817                         }
10818                         iNdEx += skippy
10819                 }
10820         }
10821
10822         if iNdEx > l {
10823                 return io.ErrUnexpectedEOF
10824         }
10825         return nil
10826 }
10827 func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
10828         l := len(dAtA)
10829         iNdEx := 0
10830         for iNdEx < l {
10831                 preIndex := iNdEx
10832                 var wire uint64
10833                 for shift := uint(0); ; shift += 7 {
10834                         if shift >= 64 {
10835                                 return ErrIntOverflowGenerated
10836                         }
10837                         if iNdEx >= l {
10838                                 return io.ErrUnexpectedEOF
10839                         }
10840                         b := dAtA[iNdEx]
10841                         iNdEx++
10842                         wire |= (uint64(b) & 0x7F) << shift
10843                         if b < 0x80 {
10844                                 break
10845                         }
10846                 }
10847                 fieldNum := int32(wire >> 3)
10848                 wireType := int(wire & 0x7)
10849                 if wireType == 4 {
10850                         return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
10851                 }
10852                 if fieldNum <= 0 {
10853                         return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
10854                 }
10855                 switch fieldNum {
10856                 case 1:
10857                         if wireType != 0 {
10858                                 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
10859                         }
10860                         m.Revision = 0
10861                         for shift := uint(0); ; shift += 7 {
10862                                 if shift >= 64 {
10863                                         return ErrIntOverflowGenerated
10864                                 }
10865                                 if iNdEx >= l {
10866                                         return io.ErrUnexpectedEOF
10867                                 }
10868                                 b := dAtA[iNdEx]
10869                                 iNdEx++
10870                                 m.Revision |= (int64(b) & 0x7F) << shift
10871                                 if b < 0x80 {
10872                                         break
10873                                 }
10874                         }
10875                 default:
10876                         iNdEx = preIndex
10877                         skippy, err := skipGenerated(dAtA[iNdEx:])
10878                         if err != nil {
10879                                 return err
10880                         }
10881                         if skippy < 0 {
10882                                 return ErrInvalidLengthGenerated
10883                         }
10884                         if (iNdEx + skippy) > l {
10885                                 return io.ErrUnexpectedEOF
10886                         }
10887                         iNdEx += skippy
10888                 }
10889         }
10890
10891         if iNdEx > l {
10892                 return io.ErrUnexpectedEOF
10893         }
10894         return nil
10895 }
10896 func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
10897         l := len(dAtA)
10898         iNdEx := 0
10899         for iNdEx < l {
10900                 preIndex := iNdEx
10901                 var wire uint64
10902                 for shift := uint(0); ; shift += 7 {
10903                         if shift >= 64 {
10904                                 return ErrIntOverflowGenerated
10905                         }
10906                         if iNdEx >= l {
10907                                 return io.ErrUnexpectedEOF
10908                         }
10909                         b := dAtA[iNdEx]
10910                         iNdEx++
10911                         wire |= (uint64(b) & 0x7F) << shift
10912                         if b < 0x80 {
10913                                 break
10914                         }
10915                 }
10916                 fieldNum := int32(wire >> 3)
10917                 wireType := int(wire & 0x7)
10918                 if wireType == 4 {
10919                         return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group")
10920                 }
10921                 if fieldNum <= 0 {
10922                         return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
10923                 }
10924                 switch fieldNum {
10925                 case 1:
10926                         if wireType != 2 {
10927                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
10928                         }
10929                         var msglen int
10930                         for shift := uint(0); ; shift += 7 {
10931                                 if shift >= 64 {
10932                                         return ErrIntOverflowGenerated
10933                                 }
10934                                 if iNdEx >= l {
10935                                         return io.ErrUnexpectedEOF
10936                                 }
10937                                 b := dAtA[iNdEx]
10938                                 iNdEx++
10939                                 msglen |= (int(b) & 0x7F) << shift
10940                                 if b < 0x80 {
10941                                         break
10942                                 }
10943                         }
10944                         if msglen < 0 {
10945                                 return ErrInvalidLengthGenerated
10946                         }
10947                         postIndex := iNdEx + msglen
10948                         if postIndex > l {
10949                                 return io.ErrUnexpectedEOF
10950                         }
10951                         if m.MaxUnavailable == nil {
10952                                 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
10953                         }
10954                         if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10955                                 return err
10956                         }
10957                         iNdEx = postIndex
10958                 default:
10959                         iNdEx = preIndex
10960                         skippy, err := skipGenerated(dAtA[iNdEx:])
10961                         if err != nil {
10962                                 return err
10963                         }
10964                         if skippy < 0 {
10965                                 return ErrInvalidLengthGenerated
10966                         }
10967                         if (iNdEx + skippy) > l {
10968                                 return io.ErrUnexpectedEOF
10969                         }
10970                         iNdEx += skippy
10971                 }
10972         }
10973
10974         if iNdEx > l {
10975                 return io.ErrUnexpectedEOF
10976         }
10977         return nil
10978 }
10979 func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
10980         l := len(dAtA)
10981         iNdEx := 0
10982         for iNdEx < l {
10983                 preIndex := iNdEx
10984                 var wire uint64
10985                 for shift := uint(0); ; shift += 7 {
10986                         if shift >= 64 {
10987                                 return ErrIntOverflowGenerated
10988                         }
10989                         if iNdEx >= l {
10990                                 return io.ErrUnexpectedEOF
10991                         }
10992                         b := dAtA[iNdEx]
10993                         iNdEx++
10994                         wire |= (uint64(b) & 0x7F) << shift
10995                         if b < 0x80 {
10996                                 break
10997                         }
10998                 }
10999                 fieldNum := int32(wire >> 3)
11000                 wireType := int(wire & 0x7)
11001                 if wireType == 4 {
11002                         return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
11003                 }
11004                 if fieldNum <= 0 {
11005                         return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
11006                 }
11007                 switch fieldNum {
11008                 case 1:
11009                         if wireType != 2 {
11010                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
11011                         }
11012                         var msglen int
11013                         for shift := uint(0); ; shift += 7 {
11014                                 if shift >= 64 {
11015                                         return ErrIntOverflowGenerated
11016                                 }
11017                                 if iNdEx >= l {
11018                                         return io.ErrUnexpectedEOF
11019                                 }
11020                                 b := dAtA[iNdEx]
11021                                 iNdEx++
11022                                 msglen |= (int(b) & 0x7F) << shift
11023                                 if b < 0x80 {
11024                                         break
11025                                 }
11026                         }
11027                         if msglen < 0 {
11028                                 return ErrInvalidLengthGenerated
11029                         }
11030                         postIndex := iNdEx + msglen
11031                         if postIndex > l {
11032                                 return io.ErrUnexpectedEOF
11033                         }
11034                         if m.MaxUnavailable == nil {
11035                                 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11036                         }
11037                         if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11038                                 return err
11039                         }
11040                         iNdEx = postIndex
11041                 case 2:
11042                         if wireType != 2 {
11043                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
11044                         }
11045                         var msglen int
11046                         for shift := uint(0); ; shift += 7 {
11047                                 if shift >= 64 {
11048                                         return ErrIntOverflowGenerated
11049                                 }
11050                                 if iNdEx >= l {
11051                                         return io.ErrUnexpectedEOF
11052                                 }
11053                                 b := dAtA[iNdEx]
11054                                 iNdEx++
11055                                 msglen |= (int(b) & 0x7F) << shift
11056                                 if b < 0x80 {
11057                                         break
11058                                 }
11059                         }
11060                         if msglen < 0 {
11061                                 return ErrInvalidLengthGenerated
11062                         }
11063                         postIndex := iNdEx + msglen
11064                         if postIndex > l {
11065                                 return io.ErrUnexpectedEOF
11066                         }
11067                         if m.MaxSurge == nil {
11068                                 m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11069                         }
11070                         if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11071                                 return err
11072                         }
11073                         iNdEx = postIndex
11074                 default:
11075                         iNdEx = preIndex
11076                         skippy, err := skipGenerated(dAtA[iNdEx:])
11077                         if err != nil {
11078                                 return err
11079                         }
11080                         if skippy < 0 {
11081                                 return ErrInvalidLengthGenerated
11082                         }
11083                         if (iNdEx + skippy) > l {
11084                                 return io.ErrUnexpectedEOF
11085                         }
11086                         iNdEx += skippy
11087                 }
11088         }
11089
11090         if iNdEx > l {
11091                 return io.ErrUnexpectedEOF
11092         }
11093         return nil
11094 }
11095 func (m *RunAsGroupStrategyOptions) Unmarshal(dAtA []byte) error {
11096         l := len(dAtA)
11097         iNdEx := 0
11098         for iNdEx < l {
11099                 preIndex := iNdEx
11100                 var wire uint64
11101                 for shift := uint(0); ; shift += 7 {
11102                         if shift >= 64 {
11103                                 return ErrIntOverflowGenerated
11104                         }
11105                         if iNdEx >= l {
11106                                 return io.ErrUnexpectedEOF
11107                         }
11108                         b := dAtA[iNdEx]
11109                         iNdEx++
11110                         wire |= (uint64(b) & 0x7F) << shift
11111                         if b < 0x80 {
11112                                 break
11113                         }
11114                 }
11115                 fieldNum := int32(wire >> 3)
11116                 wireType := int(wire & 0x7)
11117                 if wireType == 4 {
11118                         return fmt.Errorf("proto: RunAsGroupStrategyOptions: wiretype end group for non-group")
11119                 }
11120                 if fieldNum <= 0 {
11121                         return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11122                 }
11123                 switch fieldNum {
11124                 case 1:
11125                         if wireType != 2 {
11126                                 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11127                         }
11128                         var stringLen uint64
11129                         for shift := uint(0); ; shift += 7 {
11130                                 if shift >= 64 {
11131                                         return ErrIntOverflowGenerated
11132                                 }
11133                                 if iNdEx >= l {
11134                                         return io.ErrUnexpectedEOF
11135                                 }
11136                                 b := dAtA[iNdEx]
11137                                 iNdEx++
11138                                 stringLen |= (uint64(b) & 0x7F) << shift
11139                                 if b < 0x80 {
11140                                         break
11141                                 }
11142                         }
11143                         intStringLen := int(stringLen)
11144                         if intStringLen < 0 {
11145                                 return ErrInvalidLengthGenerated
11146                         }
11147                         postIndex := iNdEx + intStringLen
11148                         if postIndex > l {
11149                                 return io.ErrUnexpectedEOF
11150                         }
11151                         m.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex])
11152                         iNdEx = postIndex
11153                 case 2:
11154                         if wireType != 2 {
11155                                 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11156                         }
11157                         var msglen int
11158                         for shift := uint(0); ; shift += 7 {
11159                                 if shift >= 64 {
11160                                         return ErrIntOverflowGenerated
11161                                 }
11162                                 if iNdEx >= l {
11163                                         return io.ErrUnexpectedEOF
11164                                 }
11165                                 b := dAtA[iNdEx]
11166                                 iNdEx++
11167                                 msglen |= (int(b) & 0x7F) << shift
11168                                 if b < 0x80 {
11169                                         break
11170                                 }
11171                         }
11172                         if msglen < 0 {
11173                                 return ErrInvalidLengthGenerated
11174                         }
11175                         postIndex := iNdEx + msglen
11176                         if postIndex > l {
11177                                 return io.ErrUnexpectedEOF
11178                         }
11179                         m.Ranges = append(m.Ranges, IDRange{})
11180                         if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11181                                 return err
11182                         }
11183                         iNdEx = postIndex
11184                 default:
11185                         iNdEx = preIndex
11186                         skippy, err := skipGenerated(dAtA[iNdEx:])
11187                         if err != nil {
11188                                 return err
11189                         }
11190                         if skippy < 0 {
11191                                 return ErrInvalidLengthGenerated
11192                         }
11193                         if (iNdEx + skippy) > l {
11194                                 return io.ErrUnexpectedEOF
11195                         }
11196                         iNdEx += skippy
11197                 }
11198         }
11199
11200         if iNdEx > l {
11201                 return io.ErrUnexpectedEOF
11202         }
11203         return nil
11204 }
11205 func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error {
11206         l := len(dAtA)
11207         iNdEx := 0
11208         for iNdEx < l {
11209                 preIndex := iNdEx
11210                 var wire uint64
11211                 for shift := uint(0); ; shift += 7 {
11212                         if shift >= 64 {
11213                                 return ErrIntOverflowGenerated
11214                         }
11215                         if iNdEx >= l {
11216                                 return io.ErrUnexpectedEOF
11217                         }
11218                         b := dAtA[iNdEx]
11219                         iNdEx++
11220                         wire |= (uint64(b) & 0x7F) << shift
11221                         if b < 0x80 {
11222                                 break
11223                         }
11224                 }
11225                 fieldNum := int32(wire >> 3)
11226                 wireType := int(wire & 0x7)
11227                 if wireType == 4 {
11228                         return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group")
11229                 }
11230                 if fieldNum <= 0 {
11231                         return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11232                 }
11233                 switch fieldNum {
11234                 case 1:
11235                         if wireType != 2 {
11236                                 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11237                         }
11238                         var stringLen uint64
11239                         for shift := uint(0); ; shift += 7 {
11240                                 if shift >= 64 {
11241                                         return ErrIntOverflowGenerated
11242                                 }
11243                                 if iNdEx >= l {
11244                                         return io.ErrUnexpectedEOF
11245                                 }
11246                                 b := dAtA[iNdEx]
11247                                 iNdEx++
11248                                 stringLen |= (uint64(b) & 0x7F) << shift
11249                                 if b < 0x80 {
11250                                         break
11251                                 }
11252                         }
11253                         intStringLen := int(stringLen)
11254                         if intStringLen < 0 {
11255                                 return ErrInvalidLengthGenerated
11256                         }
11257                         postIndex := iNdEx + intStringLen
11258                         if postIndex > l {
11259                                 return io.ErrUnexpectedEOF
11260                         }
11261                         m.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex])
11262                         iNdEx = postIndex
11263                 case 2:
11264                         if wireType != 2 {
11265                                 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11266                         }
11267                         var msglen int
11268                         for shift := uint(0); ; shift += 7 {
11269                                 if shift >= 64 {
11270                                         return ErrIntOverflowGenerated
11271                                 }
11272                                 if iNdEx >= l {
11273                                         return io.ErrUnexpectedEOF
11274                                 }
11275                                 b := dAtA[iNdEx]
11276                                 iNdEx++
11277                                 msglen |= (int(b) & 0x7F) << shift
11278                                 if b < 0x80 {
11279                                         break
11280                                 }
11281                         }
11282                         if msglen < 0 {
11283                                 return ErrInvalidLengthGenerated
11284                         }
11285                         postIndex := iNdEx + msglen
11286                         if postIndex > l {
11287                                 return io.ErrUnexpectedEOF
11288                         }
11289                         m.Ranges = append(m.Ranges, IDRange{})
11290                         if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11291                                 return err
11292                         }
11293                         iNdEx = postIndex
11294                 default:
11295                         iNdEx = preIndex
11296                         skippy, err := skipGenerated(dAtA[iNdEx:])
11297                         if err != nil {
11298                                 return err
11299                         }
11300                         if skippy < 0 {
11301                                 return ErrInvalidLengthGenerated
11302                         }
11303                         if (iNdEx + skippy) > l {
11304                                 return io.ErrUnexpectedEOF
11305                         }
11306                         iNdEx += skippy
11307                 }
11308         }
11309
11310         if iNdEx > l {
11311                 return io.ErrUnexpectedEOF
11312         }
11313         return nil
11314 }
11315 func (m *SELinuxStrategyOptions) Unmarshal(dAtA []byte) error {
11316         l := len(dAtA)
11317         iNdEx := 0
11318         for iNdEx < l {
11319                 preIndex := iNdEx
11320                 var wire uint64
11321                 for shift := uint(0); ; shift += 7 {
11322                         if shift >= 64 {
11323                                 return ErrIntOverflowGenerated
11324                         }
11325                         if iNdEx >= l {
11326                                 return io.ErrUnexpectedEOF
11327                         }
11328                         b := dAtA[iNdEx]
11329                         iNdEx++
11330                         wire |= (uint64(b) & 0x7F) << shift
11331                         if b < 0x80 {
11332                                 break
11333                         }
11334                 }
11335                 fieldNum := int32(wire >> 3)
11336                 wireType := int(wire & 0x7)
11337                 if wireType == 4 {
11338                         return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group")
11339                 }
11340                 if fieldNum <= 0 {
11341                         return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11342                 }
11343                 switch fieldNum {
11344                 case 1:
11345                         if wireType != 2 {
11346                                 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11347                         }
11348                         var stringLen uint64
11349                         for shift := uint(0); ; shift += 7 {
11350                                 if shift >= 64 {
11351                                         return ErrIntOverflowGenerated
11352                                 }
11353                                 if iNdEx >= l {
11354                                         return io.ErrUnexpectedEOF
11355                                 }
11356                                 b := dAtA[iNdEx]
11357                                 iNdEx++
11358                                 stringLen |= (uint64(b) & 0x7F) << shift
11359                                 if b < 0x80 {
11360                                         break
11361                                 }
11362                         }
11363                         intStringLen := int(stringLen)
11364                         if intStringLen < 0 {
11365                                 return ErrInvalidLengthGenerated
11366                         }
11367                         postIndex := iNdEx + intStringLen
11368                         if postIndex > l {
11369                                 return io.ErrUnexpectedEOF
11370                         }
11371                         m.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex])
11372                         iNdEx = postIndex
11373                 case 2:
11374                         if wireType != 2 {
11375                                 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
11376                         }
11377                         var msglen int
11378                         for shift := uint(0); ; shift += 7 {
11379                                 if shift >= 64 {
11380                                         return ErrIntOverflowGenerated
11381                                 }
11382                                 if iNdEx >= l {
11383                                         return io.ErrUnexpectedEOF
11384                                 }
11385                                 b := dAtA[iNdEx]
11386                                 iNdEx++
11387                                 msglen |= (int(b) & 0x7F) << shift
11388                                 if b < 0x80 {
11389                                         break
11390                                 }
11391                         }
11392                         if msglen < 0 {
11393                                 return ErrInvalidLengthGenerated
11394                         }
11395                         postIndex := iNdEx + msglen
11396                         if postIndex > l {
11397                                 return io.ErrUnexpectedEOF
11398                         }
11399                         if m.SELinuxOptions == nil {
11400                                 m.SELinuxOptions = &k8s_io_api_core_v1.SELinuxOptions{}
11401                         }
11402                         if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11403                                 return err
11404                         }
11405                         iNdEx = postIndex
11406                 default:
11407                         iNdEx = preIndex
11408                         skippy, err := skipGenerated(dAtA[iNdEx:])
11409                         if err != nil {
11410                                 return err
11411                         }
11412                         if skippy < 0 {
11413                                 return ErrInvalidLengthGenerated
11414                         }
11415                         if (iNdEx + skippy) > l {
11416                                 return io.ErrUnexpectedEOF
11417                         }
11418                         iNdEx += skippy
11419                 }
11420         }
11421
11422         if iNdEx > l {
11423                 return io.ErrUnexpectedEOF
11424         }
11425         return nil
11426 }
11427 func (m *Scale) Unmarshal(dAtA []byte) error {
11428         l := len(dAtA)
11429         iNdEx := 0
11430         for iNdEx < l {
11431                 preIndex := iNdEx
11432                 var wire uint64
11433                 for shift := uint(0); ; shift += 7 {
11434                         if shift >= 64 {
11435                                 return ErrIntOverflowGenerated
11436                         }
11437                         if iNdEx >= l {
11438                                 return io.ErrUnexpectedEOF
11439                         }
11440                         b := dAtA[iNdEx]
11441                         iNdEx++
11442                         wire |= (uint64(b) & 0x7F) << shift
11443                         if b < 0x80 {
11444                                 break
11445                         }
11446                 }
11447                 fieldNum := int32(wire >> 3)
11448                 wireType := int(wire & 0x7)
11449                 if wireType == 4 {
11450                         return fmt.Errorf("proto: Scale: wiretype end group for non-group")
11451                 }
11452                 if fieldNum <= 0 {
11453                         return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
11454                 }
11455                 switch fieldNum {
11456                 case 1:
11457                         if wireType != 2 {
11458                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
11459                         }
11460                         var msglen int
11461                         for shift := uint(0); ; shift += 7 {
11462                                 if shift >= 64 {
11463                                         return ErrIntOverflowGenerated
11464                                 }
11465                                 if iNdEx >= l {
11466                                         return io.ErrUnexpectedEOF
11467                                 }
11468                                 b := dAtA[iNdEx]
11469                                 iNdEx++
11470                                 msglen |= (int(b) & 0x7F) << shift
11471                                 if b < 0x80 {
11472                                         break
11473                                 }
11474                         }
11475                         if msglen < 0 {
11476                                 return ErrInvalidLengthGenerated
11477                         }
11478                         postIndex := iNdEx + msglen
11479                         if postIndex > l {
11480                                 return io.ErrUnexpectedEOF
11481                         }
11482                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11483                                 return err
11484                         }
11485                         iNdEx = postIndex
11486                 case 2:
11487                         if wireType != 2 {
11488                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
11489                         }
11490                         var msglen int
11491                         for shift := uint(0); ; shift += 7 {
11492                                 if shift >= 64 {
11493                                         return ErrIntOverflowGenerated
11494                                 }
11495                                 if iNdEx >= l {
11496                                         return io.ErrUnexpectedEOF
11497                                 }
11498                                 b := dAtA[iNdEx]
11499                                 iNdEx++
11500                                 msglen |= (int(b) & 0x7F) << shift
11501                                 if b < 0x80 {
11502                                         break
11503                                 }
11504                         }
11505                         if msglen < 0 {
11506                                 return ErrInvalidLengthGenerated
11507                         }
11508                         postIndex := iNdEx + msglen
11509                         if postIndex > l {
11510                                 return io.ErrUnexpectedEOF
11511                         }
11512                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11513                                 return err
11514                         }
11515                         iNdEx = postIndex
11516                 case 3:
11517                         if wireType != 2 {
11518                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
11519                         }
11520                         var msglen int
11521                         for shift := uint(0); ; shift += 7 {
11522                                 if shift >= 64 {
11523                                         return ErrIntOverflowGenerated
11524                                 }
11525                                 if iNdEx >= l {
11526                                         return io.ErrUnexpectedEOF
11527                                 }
11528                                 b := dAtA[iNdEx]
11529                                 iNdEx++
11530                                 msglen |= (int(b) & 0x7F) << shift
11531                                 if b < 0x80 {
11532                                         break
11533                                 }
11534                         }
11535                         if msglen < 0 {
11536                                 return ErrInvalidLengthGenerated
11537                         }
11538                         postIndex := iNdEx + msglen
11539                         if postIndex > l {
11540                                 return io.ErrUnexpectedEOF
11541                         }
11542                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11543                                 return err
11544                         }
11545                         iNdEx = postIndex
11546                 default:
11547                         iNdEx = preIndex
11548                         skippy, err := skipGenerated(dAtA[iNdEx:])
11549                         if err != nil {
11550                                 return err
11551                         }
11552                         if skippy < 0 {
11553                                 return ErrInvalidLengthGenerated
11554                         }
11555                         if (iNdEx + skippy) > l {
11556                                 return io.ErrUnexpectedEOF
11557                         }
11558                         iNdEx += skippy
11559                 }
11560         }
11561
11562         if iNdEx > l {
11563                 return io.ErrUnexpectedEOF
11564         }
11565         return nil
11566 }
11567 func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
11568         l := len(dAtA)
11569         iNdEx := 0
11570         for iNdEx < l {
11571                 preIndex := iNdEx
11572                 var wire uint64
11573                 for shift := uint(0); ; shift += 7 {
11574                         if shift >= 64 {
11575                                 return ErrIntOverflowGenerated
11576                         }
11577                         if iNdEx >= l {
11578                                 return io.ErrUnexpectedEOF
11579                         }
11580                         b := dAtA[iNdEx]
11581                         iNdEx++
11582                         wire |= (uint64(b) & 0x7F) << shift
11583                         if b < 0x80 {
11584                                 break
11585                         }
11586                 }
11587                 fieldNum := int32(wire >> 3)
11588                 wireType := int(wire & 0x7)
11589                 if wireType == 4 {
11590                         return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
11591                 }
11592                 if fieldNum <= 0 {
11593                         return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
11594                 }
11595                 switch fieldNum {
11596                 case 1:
11597                         if wireType != 0 {
11598                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
11599                         }
11600                         m.Replicas = 0
11601                         for shift := uint(0); ; shift += 7 {
11602                                 if shift >= 64 {
11603                                         return ErrIntOverflowGenerated
11604                                 }
11605                                 if iNdEx >= l {
11606                                         return io.ErrUnexpectedEOF
11607                                 }
11608                                 b := dAtA[iNdEx]
11609                                 iNdEx++
11610                                 m.Replicas |= (int32(b) & 0x7F) << shift
11611                                 if b < 0x80 {
11612                                         break
11613                                 }
11614                         }
11615                 default:
11616                         iNdEx = preIndex
11617                         skippy, err := skipGenerated(dAtA[iNdEx:])
11618                         if err != nil {
11619                                 return err
11620                         }
11621                         if skippy < 0 {
11622                                 return ErrInvalidLengthGenerated
11623                         }
11624                         if (iNdEx + skippy) > l {
11625                                 return io.ErrUnexpectedEOF
11626                         }
11627                         iNdEx += skippy
11628                 }
11629         }
11630
11631         if iNdEx > l {
11632                 return io.ErrUnexpectedEOF
11633         }
11634         return nil
11635 }
11636 func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
11637         l := len(dAtA)
11638         iNdEx := 0
11639         for iNdEx < l {
11640                 preIndex := iNdEx
11641                 var wire uint64
11642                 for shift := uint(0); ; shift += 7 {
11643                         if shift >= 64 {
11644                                 return ErrIntOverflowGenerated
11645                         }
11646                         if iNdEx >= l {
11647                                 return io.ErrUnexpectedEOF
11648                         }
11649                         b := dAtA[iNdEx]
11650                         iNdEx++
11651                         wire |= (uint64(b) & 0x7F) << shift
11652                         if b < 0x80 {
11653                                 break
11654                         }
11655                 }
11656                 fieldNum := int32(wire >> 3)
11657                 wireType := int(wire & 0x7)
11658                 if wireType == 4 {
11659                         return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
11660                 }
11661                 if fieldNum <= 0 {
11662                         return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
11663                 }
11664                 switch fieldNum {
11665                 case 1:
11666                         if wireType != 0 {
11667                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
11668                         }
11669                         m.Replicas = 0
11670                         for shift := uint(0); ; shift += 7 {
11671                                 if shift >= 64 {
11672                                         return ErrIntOverflowGenerated
11673                                 }
11674                                 if iNdEx >= l {
11675                                         return io.ErrUnexpectedEOF
11676                                 }
11677                                 b := dAtA[iNdEx]
11678                                 iNdEx++
11679                                 m.Replicas |= (int32(b) & 0x7F) << shift
11680                                 if b < 0x80 {
11681                                         break
11682                                 }
11683                         }
11684                 case 2:
11685                         if wireType != 2 {
11686                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
11687                         }
11688                         var msglen int
11689                         for shift := uint(0); ; shift += 7 {
11690                                 if shift >= 64 {
11691                                         return ErrIntOverflowGenerated
11692                                 }
11693                                 if iNdEx >= l {
11694                                         return io.ErrUnexpectedEOF
11695                                 }
11696                                 b := dAtA[iNdEx]
11697                                 iNdEx++
11698                                 msglen |= (int(b) & 0x7F) << shift
11699                                 if b < 0x80 {
11700                                         break
11701                                 }
11702                         }
11703                         if msglen < 0 {
11704                                 return ErrInvalidLengthGenerated
11705                         }
11706                         postIndex := iNdEx + msglen
11707                         if postIndex > l {
11708                                 return io.ErrUnexpectedEOF
11709                         }
11710                         if m.Selector == nil {
11711                                 m.Selector = make(map[string]string)
11712                         }
11713                         var mapkey string
11714                         var mapvalue string
11715                         for iNdEx < postIndex {
11716                                 entryPreIndex := iNdEx
11717                                 var wire uint64
11718                                 for shift := uint(0); ; shift += 7 {
11719                                         if shift >= 64 {
11720                                                 return ErrIntOverflowGenerated
11721                                         }
11722                                         if iNdEx >= l {
11723                                                 return io.ErrUnexpectedEOF
11724                                         }
11725                                         b := dAtA[iNdEx]
11726                                         iNdEx++
11727                                         wire |= (uint64(b) & 0x7F) << shift
11728                                         if b < 0x80 {
11729                                                 break
11730                                         }
11731                                 }
11732                                 fieldNum := int32(wire >> 3)
11733                                 if fieldNum == 1 {
11734                                         var stringLenmapkey uint64
11735                                         for shift := uint(0); ; shift += 7 {
11736                                                 if shift >= 64 {
11737                                                         return ErrIntOverflowGenerated
11738                                                 }
11739                                                 if iNdEx >= l {
11740                                                         return io.ErrUnexpectedEOF
11741                                                 }
11742                                                 b := dAtA[iNdEx]
11743                                                 iNdEx++
11744                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
11745                                                 if b < 0x80 {
11746                                                         break
11747                                                 }
11748                                         }
11749                                         intStringLenmapkey := int(stringLenmapkey)
11750                                         if intStringLenmapkey < 0 {
11751                                                 return ErrInvalidLengthGenerated
11752                                         }
11753                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
11754                                         if postStringIndexmapkey > l {
11755                                                 return io.ErrUnexpectedEOF
11756                                         }
11757                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
11758                                         iNdEx = postStringIndexmapkey
11759                                 } else if fieldNum == 2 {
11760                                         var stringLenmapvalue uint64
11761                                         for shift := uint(0); ; shift += 7 {
11762                                                 if shift >= 64 {
11763                                                         return ErrIntOverflowGenerated
11764                                                 }
11765                                                 if iNdEx >= l {
11766                                                         return io.ErrUnexpectedEOF
11767                                                 }
11768                                                 b := dAtA[iNdEx]
11769                                                 iNdEx++
11770                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
11771                                                 if b < 0x80 {
11772                                                         break
11773                                                 }
11774                                         }
11775                                         intStringLenmapvalue := int(stringLenmapvalue)
11776                                         if intStringLenmapvalue < 0 {
11777                                                 return ErrInvalidLengthGenerated
11778                                         }
11779                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
11780                                         if postStringIndexmapvalue > l {
11781                                                 return io.ErrUnexpectedEOF
11782                                         }
11783                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
11784                                         iNdEx = postStringIndexmapvalue
11785                                 } else {
11786                                         iNdEx = entryPreIndex
11787                                         skippy, err := skipGenerated(dAtA[iNdEx:])
11788                                         if err != nil {
11789                                                 return err
11790                                         }
11791                                         if skippy < 0 {
11792                                                 return ErrInvalidLengthGenerated
11793                                         }
11794                                         if (iNdEx + skippy) > postIndex {
11795                                                 return io.ErrUnexpectedEOF
11796                                         }
11797                                         iNdEx += skippy
11798                                 }
11799                         }
11800                         m.Selector[mapkey] = mapvalue
11801                         iNdEx = postIndex
11802                 case 3:
11803                         if wireType != 2 {
11804                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
11805                         }
11806                         var stringLen uint64
11807                         for shift := uint(0); ; shift += 7 {
11808                                 if shift >= 64 {
11809                                         return ErrIntOverflowGenerated
11810                                 }
11811                                 if iNdEx >= l {
11812                                         return io.ErrUnexpectedEOF
11813                                 }
11814                                 b := dAtA[iNdEx]
11815                                 iNdEx++
11816                                 stringLen |= (uint64(b) & 0x7F) << shift
11817                                 if b < 0x80 {
11818                                         break
11819                                 }
11820                         }
11821                         intStringLen := int(stringLen)
11822                         if intStringLen < 0 {
11823                                 return ErrInvalidLengthGenerated
11824                         }
11825                         postIndex := iNdEx + intStringLen
11826                         if postIndex > l {
11827                                 return io.ErrUnexpectedEOF
11828                         }
11829                         m.TargetSelector = string(dAtA[iNdEx:postIndex])
11830                         iNdEx = postIndex
11831                 default:
11832                         iNdEx = preIndex
11833                         skippy, err := skipGenerated(dAtA[iNdEx:])
11834                         if err != nil {
11835                                 return err
11836                         }
11837                         if skippy < 0 {
11838                                 return ErrInvalidLengthGenerated
11839                         }
11840                         if (iNdEx + skippy) > l {
11841                                 return io.ErrUnexpectedEOF
11842                         }
11843                         iNdEx += skippy
11844                 }
11845         }
11846
11847         if iNdEx > l {
11848                 return io.ErrUnexpectedEOF
11849         }
11850         return nil
11851 }
11852 func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error {
11853         l := len(dAtA)
11854         iNdEx := 0
11855         for iNdEx < l {
11856                 preIndex := iNdEx
11857                 var wire uint64
11858                 for shift := uint(0); ; shift += 7 {
11859                         if shift >= 64 {
11860                                 return ErrIntOverflowGenerated
11861                         }
11862                         if iNdEx >= l {
11863                                 return io.ErrUnexpectedEOF
11864                         }
11865                         b := dAtA[iNdEx]
11866                         iNdEx++
11867                         wire |= (uint64(b) & 0x7F) << shift
11868                         if b < 0x80 {
11869                                 break
11870                         }
11871                 }
11872                 fieldNum := int32(wire >> 3)
11873                 wireType := int(wire & 0x7)
11874                 if wireType == 4 {
11875                         return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group")
11876                 }
11877                 if fieldNum <= 0 {
11878                         return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11879                 }
11880                 switch fieldNum {
11881                 case 1:
11882                         if wireType != 2 {
11883                                 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11884                         }
11885                         var stringLen uint64
11886                         for shift := uint(0); ; shift += 7 {
11887                                 if shift >= 64 {
11888                                         return ErrIntOverflowGenerated
11889                                 }
11890                                 if iNdEx >= l {
11891                                         return io.ErrUnexpectedEOF
11892                                 }
11893                                 b := dAtA[iNdEx]
11894                                 iNdEx++
11895                                 stringLen |= (uint64(b) & 0x7F) << shift
11896                                 if b < 0x80 {
11897                                         break
11898                                 }
11899                         }
11900                         intStringLen := int(stringLen)
11901                         if intStringLen < 0 {
11902                                 return ErrInvalidLengthGenerated
11903                         }
11904                         postIndex := iNdEx + intStringLen
11905                         if postIndex > l {
11906                                 return io.ErrUnexpectedEOF
11907                         }
11908                         m.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex])
11909                         iNdEx = postIndex
11910                 case 2:
11911                         if wireType != 2 {
11912                                 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11913                         }
11914                         var msglen int
11915                         for shift := uint(0); ; shift += 7 {
11916                                 if shift >= 64 {
11917                                         return ErrIntOverflowGenerated
11918                                 }
11919                                 if iNdEx >= l {
11920                                         return io.ErrUnexpectedEOF
11921                                 }
11922                                 b := dAtA[iNdEx]
11923                                 iNdEx++
11924                                 msglen |= (int(b) & 0x7F) << shift
11925                                 if b < 0x80 {
11926                                         break
11927                                 }
11928                         }
11929                         if msglen < 0 {
11930                                 return ErrInvalidLengthGenerated
11931                         }
11932                         postIndex := iNdEx + msglen
11933                         if postIndex > l {
11934                                 return io.ErrUnexpectedEOF
11935                         }
11936                         m.Ranges = append(m.Ranges, IDRange{})
11937                         if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11938                                 return err
11939                         }
11940                         iNdEx = postIndex
11941                 default:
11942                         iNdEx = preIndex
11943                         skippy, err := skipGenerated(dAtA[iNdEx:])
11944                         if err != nil {
11945                                 return err
11946                         }
11947                         if skippy < 0 {
11948                                 return ErrInvalidLengthGenerated
11949                         }
11950                         if (iNdEx + skippy) > l {
11951                                 return io.ErrUnexpectedEOF
11952                         }
11953                         iNdEx += skippy
11954                 }
11955         }
11956
11957         if iNdEx > l {
11958                 return io.ErrUnexpectedEOF
11959         }
11960         return nil
11961 }
11962 func skipGenerated(dAtA []byte) (n int, err error) {
11963         l := len(dAtA)
11964         iNdEx := 0
11965         for iNdEx < l {
11966                 var wire uint64
11967                 for shift := uint(0); ; shift += 7 {
11968                         if shift >= 64 {
11969                                 return 0, ErrIntOverflowGenerated
11970                         }
11971                         if iNdEx >= l {
11972                                 return 0, io.ErrUnexpectedEOF
11973                         }
11974                         b := dAtA[iNdEx]
11975                         iNdEx++
11976                         wire |= (uint64(b) & 0x7F) << shift
11977                         if b < 0x80 {
11978                                 break
11979                         }
11980                 }
11981                 wireType := int(wire & 0x7)
11982                 switch wireType {
11983                 case 0:
11984                         for shift := uint(0); ; shift += 7 {
11985                                 if shift >= 64 {
11986                                         return 0, ErrIntOverflowGenerated
11987                                 }
11988                                 if iNdEx >= l {
11989                                         return 0, io.ErrUnexpectedEOF
11990                                 }
11991                                 iNdEx++
11992                                 if dAtA[iNdEx-1] < 0x80 {
11993                                         break
11994                                 }
11995                         }
11996                         return iNdEx, nil
11997                 case 1:
11998                         iNdEx += 8
11999                         return iNdEx, nil
12000                 case 2:
12001                         var length int
12002                         for shift := uint(0); ; shift += 7 {
12003                                 if shift >= 64 {
12004                                         return 0, ErrIntOverflowGenerated
12005                                 }
12006                                 if iNdEx >= l {
12007                                         return 0, io.ErrUnexpectedEOF
12008                                 }
12009                                 b := dAtA[iNdEx]
12010                                 iNdEx++
12011                                 length |= (int(b) & 0x7F) << shift
12012                                 if b < 0x80 {
12013                                         break
12014                                 }
12015                         }
12016                         iNdEx += length
12017                         if length < 0 {
12018                                 return 0, ErrInvalidLengthGenerated
12019                         }
12020                         return iNdEx, nil
12021                 case 3:
12022                         for {
12023                                 var innerWire uint64
12024                                 var start int = iNdEx
12025                                 for shift := uint(0); ; shift += 7 {
12026                                         if shift >= 64 {
12027                                                 return 0, ErrIntOverflowGenerated
12028                                         }
12029                                         if iNdEx >= l {
12030                                                 return 0, io.ErrUnexpectedEOF
12031                                         }
12032                                         b := dAtA[iNdEx]
12033                                         iNdEx++
12034                                         innerWire |= (uint64(b) & 0x7F) << shift
12035                                         if b < 0x80 {
12036                                                 break
12037                                         }
12038                                 }
12039                                 innerWireType := int(innerWire & 0x7)
12040                                 if innerWireType == 4 {
12041                                         break
12042                                 }
12043                                 next, err := skipGenerated(dAtA[start:])
12044                                 if err != nil {
12045                                         return 0, err
12046                                 }
12047                                 iNdEx = start + next
12048                         }
12049                         return iNdEx, nil
12050                 case 4:
12051                         return iNdEx, nil
12052                 case 5:
12053                         iNdEx += 4
12054                         return iNdEx, nil
12055                 default:
12056                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
12057                 }
12058         }
12059         panic("unreachable")
12060 }
12061
12062 var (
12063         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
12064         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
12065 )
12066
12067 func init() {
12068         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptorGenerated)
12069 }
12070
12071 var fileDescriptorGenerated = []byte{
12072         // 3587 bytes of a gzipped FileDescriptorProto
12073         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcd, 0x6f, 0x1c, 0x47,
12074         0x76, 0x57, 0xcf, 0x0c, 0x39, 0xc3, 0x47, 0xf1, 0xab, 0x48, 0x91, 0x63, 0xc9, 0xe2, 0xc8, 0x6d,
12075         0x40, 0x91, 0x1d, 0x69, 0xc6, 0x92, 0x2d, 0x59, 0xb1, 0x10, 0xdb, 0x1c, 0x52, 0x94, 0xe8, 0xf0,
12076         0x63, 0x5c, 0x43, 0x2a, 0x86, 0x11, 0x3b, 0x6e, 0xce, 0x14, 0x87, 0x2d, 0xf6, 0x74, 0xb7, 0xbb,
12077         0x6b, 0x68, 0x0e, 0x90, 0x43, 0x0e, 0x49, 0x80, 0x00, 0x09, 0x92, 0x8b, 0x93, 0x1c, 0x63, 0x04,
12078         0xc8, 0x69, 0x17, 0xbb, 0xb7, 0xdd, 0x83, 0x61, 0x60, 0x01, 0x2f, 0x20, 0x2c, 0xbc, 0x80, 0x6f,
12079         0xeb, 0x13, 0xb1, 0xa6, 0x4f, 0x8b, 0xfd, 0x07, 0x16, 0x3a, 0x2c, 0x16, 0x55, 0x5d, 0xfd, 0xdd,
12080         0xad, 0x69, 0xd2, 0x12, 0xb1, 0x58, 0xec, 0x8d, 0x53, 0xef, 0xbd, 0xdf, 0x7b, 0x55, 0xf5, 0xea,
12081         0xbd, 0xd7, 0x55, 0x8f, 0xb0, 0xbc, 0x77, 0xdb, 0xae, 0xaa, 0x46, 0x6d, 0xaf, 0xb7, 0x4d, 0x2c,
12082         0x9d, 0x50, 0x62, 0xd7, 0xf6, 0x89, 0xde, 0x36, 0xac, 0x9a, 0x20, 0x28, 0xa6, 0x5a, 0x23, 0x07,
12083         0x94, 0xe8, 0xb6, 0x6a, 0xe8, 0x76, 0x6d, 0xff, 0xfa, 0x36, 0xa1, 0xca, 0xf5, 0x5a, 0x87, 0xe8,
12084         0xc4, 0x52, 0x28, 0x69, 0x57, 0x4d, 0xcb, 0xa0, 0x06, 0xba, 0xe8, 0xb0, 0x57, 0x15, 0x53, 0xad,
12085         0xfa, 0xec, 0x55, 0xc1, 0x7e, 0xfe, 0x5a, 0x47, 0xa5, 0xbb, 0xbd, 0xed, 0x6a, 0xcb, 0xe8, 0xd6,
12086         0x3a, 0x46, 0xc7, 0xa8, 0x71, 0xa9, 0xed, 0xde, 0x0e, 0xff, 0xc5, 0x7f, 0xf0, 0xbf, 0x1c, 0xb4,
12087         0xf3, 0x72, 0x40, 0x79, 0xcb, 0xb0, 0x48, 0x6d, 0x3f, 0xa6, 0xf1, 0xfc, 0x6b, 0x3e, 0x4f, 0x57,
12088         0x69, 0xed, 0xaa, 0x3a, 0xb1, 0xfa, 0x35, 0x73, 0xaf, 0xc3, 0x06, 0xec, 0x5a, 0x97, 0x50, 0x25,
12089         0x49, 0xaa, 0x96, 0x26, 0x65, 0xf5, 0x74, 0xaa, 0x76, 0x49, 0x4c, 0xe0, 0xd6, 0x20, 0x01, 0xbb,
12090         0xb5, 0x4b, 0xba, 0x4a, 0x4c, 0xee, 0xd5, 0x34, 0xb9, 0x1e, 0x55, 0xb5, 0x9a, 0xaa, 0x53, 0x9b,
12091         0x5a, 0x51, 0x21, 0xf9, 0x0e, 0x4c, 0x2d, 0x68, 0x9a, 0xf1, 0x09, 0x69, 0x2f, 0x6b, 0xe4, 0xe0,
12092         0x81, 0xa1, 0xf5, 0xba, 0x04, 0x5d, 0x86, 0xe1, 0xb6, 0xa5, 0xee, 0x13, 0xab, 0x2c, 0x5d, 0x92,
12093         0xae, 0x8c, 0xd4, 0xc7, 0x1f, 0x1d, 0x56, 0xce, 0x1c, 0x1d, 0x56, 0x86, 0x97, 0xf8, 0x28, 0x16,
12094         0x54, 0xd9, 0x86, 0x09, 0x21, 0x7c, 0xdf, 0xb0, 0x69, 0x43, 0xa1, 0xbb, 0xe8, 0x06, 0x80, 0xa9,
12095         0xd0, 0xdd, 0x86, 0x45, 0x76, 0xd4, 0x03, 0x21, 0x8e, 0x84, 0x38, 0x34, 0x3c, 0x0a, 0x0e, 0x70,
12096         0xa1, 0xab, 0x50, 0xb2, 0x88, 0xd2, 0xde, 0xd0, 0xb5, 0x7e, 0x39, 0x77, 0x49, 0xba, 0x52, 0xaa,
12097         0x4f, 0x0a, 0x89, 0x12, 0x16, 0xe3, 0xd8, 0xe3, 0x90, 0x3f, 0xcd, 0xc1, 0xc8, 0x92, 0x42, 0xba,
12098         0x86, 0xde, 0x24, 0x14, 0x7d, 0x04, 0x25, 0xb6, 0xf0, 0x6d, 0x85, 0x2a, 0x5c, 0xdb, 0xe8, 0x8d,
12099         0x57, 0xaa, 0xbe, 0x63, 0x78, 0xeb, 0x50, 0x35, 0xf7, 0x3a, 0x6c, 0xc0, 0xae, 0x32, 0xee, 0xea,
12100         0xfe, 0xf5, 0xea, 0xc6, 0xf6, 0x43, 0xd2, 0xa2, 0x6b, 0x84, 0x2a, 0xbe, 0x7d, 0xfe, 0x18, 0xf6,
12101         0x50, 0xd1, 0x3a, 0x14, 0x6c, 0x93, 0xb4, 0xb8, 0x65, 0xa3, 0x37, 0xae, 0x56, 0x9f, 0xe8, 0x76,
12102         0x55, 0xcf, 0xb2, 0xa6, 0x49, 0x5a, 0xf5, 0xb3, 0x02, 0xb9, 0xc0, 0x7e, 0x61, 0x8e, 0x83, 0x1e,
12103         0xc0, 0xb0, 0x4d, 0x15, 0xda, 0xb3, 0xcb, 0x79, 0x8e, 0x58, 0xcd, 0x8c, 0xc8, 0xa5, 0xfc, 0xcd,
12104         0x70, 0x7e, 0x63, 0x81, 0x26, 0xff, 0x26, 0x07, 0xc8, 0xe3, 0x5d, 0x34, 0xf4, 0xb6, 0x4a, 0x55,
12105         0x43, 0x47, 0x6f, 0x40, 0x81, 0xf6, 0x4d, 0x22, 0xb6, 0xe2, 0xb2, 0x6b, 0xd0, 0x66, 0xdf, 0x24,
12106         0x8f, 0x0f, 0x2b, 0xb3, 0x71, 0x09, 0x46, 0xc1, 0x5c, 0x06, 0xad, 0x7a, 0xa6, 0xe6, 0xb8, 0xf4,
12107         0x6b, 0x61, 0xd5, 0x8f, 0x0f, 0x2b, 0x09, 0xc7, 0xa6, 0xea, 0x21, 0x85, 0x0d, 0x44, 0xfb, 0x80,
12108         0x34, 0xc5, 0xa6, 0x9b, 0x96, 0xa2, 0xdb, 0x8e, 0x26, 0xb5, 0x4b, 0xc4, 0x22, 0xbc, 0x9c, 0x6d,
12109         0xd3, 0x98, 0x44, 0xfd, 0xbc, 0xb0, 0x02, 0xad, 0xc6, 0xd0, 0x70, 0x82, 0x06, 0xe6, 0xcd, 0x16,
12110         0x51, 0x6c, 0x43, 0x2f, 0x17, 0xc2, 0xde, 0x8c, 0xf9, 0x28, 0x16, 0x54, 0xf4, 0x12, 0x14, 0xbb,
12111         0xc4, 0xb6, 0x95, 0x0e, 0x29, 0x0f, 0x71, 0xc6, 0x09, 0xc1, 0x58, 0x5c, 0x73, 0x86, 0xb1, 0x4b,
12112         0x97, 0x3f, 0x97, 0x60, 0xcc, 0x5b, 0xb9, 0x55, 0xd5, 0xa6, 0xe8, 0xef, 0x62, 0x7e, 0x58, 0xcd,
12113         0x36, 0x25, 0x26, 0xcd, 0xbd, 0xd0, 0xf3, 0x79, 0x77, 0x24, 0xe0, 0x83, 0x6b, 0x30, 0xa4, 0x52,
12114         0xd2, 0x65, 0xfb, 0x90, 0xbf, 0x32, 0x7a, 0xe3, 0x4a, 0x56, 0x97, 0xa9, 0x8f, 0x09, 0xd0, 0xa1,
12115         0x15, 0x26, 0x8e, 0x1d, 0x14, 0xf9, 0xbf, 0x0a, 0x01, 0xf3, 0x99, 0x6b, 0xa2, 0x0f, 0xa0, 0x64,
12116         0x13, 0x8d, 0xb4, 0xa8, 0x61, 0x09, 0xf3, 0x5f, 0xcd, 0x68, 0xbe, 0xb2, 0x4d, 0xb4, 0xa6, 0x10,
12117         0xad, 0x9f, 0x65, 0xf6, 0xbb, 0xbf, 0xb0, 0x07, 0x89, 0xde, 0x85, 0x12, 0x25, 0x5d, 0x53, 0x53,
12118         0x28, 0x11, 0xe7, 0xe8, 0xc5, 0xe0, 0x14, 0x98, 0xe7, 0x30, 0xb0, 0x86, 0xd1, 0xde, 0x14, 0x6c,
12119         0xfc, 0xf8, 0x78, 0x4b, 0xe2, 0x8e, 0x62, 0x0f, 0x06, 0xed, 0xc3, 0x78, 0xcf, 0x6c, 0x33, 0x4e,
12120         0xca, 0xe2, 0x59, 0xa7, 0x2f, 0x3c, 0xe9, 0x56, 0xd6, 0xb5, 0xd9, 0x0a, 0x49, 0xd7, 0x67, 0x85,
12121         0xae, 0xf1, 0xf0, 0x38, 0x8e, 0x68, 0x41, 0x0b, 0x30, 0xd1, 0x55, 0x75, 0x16, 0x97, 0xfa, 0x4d,
12122         0xd2, 0x32, 0xf4, 0xb6, 0xcd, 0xdd, 0x6a, 0xa8, 0x3e, 0x27, 0x00, 0x26, 0xd6, 0xc2, 0x64, 0x1c,
12123         0xe5, 0x47, 0xef, 0x00, 0x72, 0xa7, 0x71, 0xcf, 0x09, 0xc7, 0xaa, 0xa1, 0x73, 0x9f, 0xcb, 0xfb,
12124         0xce, 0xbd, 0x19, 0xe3, 0xc0, 0x09, 0x52, 0x68, 0x15, 0x66, 0x2c, 0xb2, 0xaf, 0xb2, 0x39, 0xde,
12125         0x57, 0x6d, 0x6a, 0x58, 0xfd, 0x55, 0xb5, 0xab, 0xd2, 0xf2, 0x30, 0xb7, 0xa9, 0x7c, 0x74, 0x58,
12126         0x99, 0xc1, 0x09, 0x74, 0x9c, 0x28, 0x25, 0xff, 0xf7, 0x30, 0x4c, 0x44, 0xe2, 0x0d, 0x7a, 0x00,
12127         0xb3, 0xad, 0x9e, 0x65, 0x11, 0x9d, 0xae, 0xf7, 0xba, 0xdb, 0xc4, 0x6a, 0xb6, 0x76, 0x49, 0xbb,
12128         0xa7, 0x91, 0x36, 0x77, 0x94, 0xa1, 0xfa, 0xbc, 0xb0, 0x78, 0x76, 0x31, 0x91, 0x0b, 0xa7, 0x48,
12129         0xb3, 0x55, 0xd0, 0xf9, 0xd0, 0x9a, 0x6a, 0xdb, 0x1e, 0x66, 0x8e, 0x63, 0x7a, 0xab, 0xb0, 0x1e,
12130         0xe3, 0xc0, 0x09, 0x52, 0xcc, 0xc6, 0x36, 0xb1, 0x55, 0x8b, 0xb4, 0xa3, 0x36, 0xe6, 0xc3, 0x36,
12131         0x2e, 0x25, 0x72, 0xe1, 0x14, 0x69, 0x74, 0x13, 0x46, 0x1d, 0x6d, 0x7c, 0xff, 0xc4, 0x46, 0x4f,
12132         0x0b, 0xb0, 0xd1, 0x75, 0x9f, 0x84, 0x83, 0x7c, 0x6c, 0x6a, 0xc6, 0xb6, 0x4d, 0xac, 0x7d, 0xd2,
12133         0x4e, 0xdf, 0xe0, 0x8d, 0x18, 0x07, 0x4e, 0x90, 0x62, 0x53, 0x73, 0x3c, 0x30, 0x36, 0xb5, 0xe1,
12134         0xf0, 0xd4, 0xb6, 0x12, 0xb9, 0x70, 0x8a, 0x34, 0xf3, 0x63, 0xc7, 0xe4, 0x85, 0x7d, 0x45, 0xd5,
12135         0x94, 0x6d, 0x8d, 0x94, 0x8b, 0x61, 0x3f, 0x5e, 0x0f, 0x93, 0x71, 0x94, 0x1f, 0xdd, 0x83, 0x29,
12136         0x67, 0x68, 0x4b, 0x57, 0x3c, 0x90, 0x12, 0x07, 0x79, 0x4e, 0x80, 0x4c, 0xad, 0x47, 0x19, 0x70,
12137         0x5c, 0x06, 0xbd, 0x01, 0xe3, 0x2d, 0x43, 0xd3, 0xb8, 0x3f, 0x2e, 0x1a, 0x3d, 0x9d, 0x96, 0x47,
12138         0x38, 0x0a, 0x62, 0xe7, 0x71, 0x31, 0x44, 0xc1, 0x11, 0x4e, 0x44, 0x00, 0x5a, 0x6e, 0xc2, 0xb1,
12139         0xcb, 0xc0, 0xe3, 0xe3, 0xf5, 0xac, 0x31, 0xc0, 0x4b, 0x55, 0x7e, 0x0d, 0xe0, 0x0d, 0xd9, 0x38,
12140         0x00, 0x2c, 0xff, 0x42, 0x82, 0xb9, 0x94, 0xd0, 0x81, 0xde, 0x0a, 0xa5, 0xd8, 0xbf, 0x8c, 0xa4,
12141         0xd8, 0x0b, 0x29, 0x62, 0x81, 0x3c, 0xab, 0xc3, 0x98, 0xc5, 0x66, 0xa5, 0x77, 0x1c, 0x16, 0x11,
12142         0x23, 0x6f, 0x0e, 0x98, 0x06, 0x0e, 0xca, 0xf8, 0x31, 0x7f, 0xea, 0xe8, 0xb0, 0x32, 0x16, 0xa2,
12143         0xe1, 0x30, 0xbc, 0xfc, 0x3f, 0x39, 0x80, 0x25, 0x62, 0x6a, 0x46, 0xbf, 0x4b, 0xf4, 0xd3, 0xa8,
12144         0xa1, 0x36, 0x42, 0x35, 0xd4, 0xb5, 0x41, 0xdb, 0xe3, 0x99, 0x96, 0x5a, 0x44, 0xfd, 0x6d, 0xa4,
12145         0x88, 0xaa, 0x65, 0x87, 0x7c, 0x72, 0x15, 0xf5, 0xab, 0x3c, 0x4c, 0xfb, 0xcc, 0x7e, 0x19, 0x75,
12146         0x27, 0xb4, 0xc7, 0x7f, 0x11, 0xd9, 0xe3, 0xb9, 0x04, 0x91, 0x67, 0x56, 0x47, 0x3d, 0xfd, 0x7a,
12147         0x06, 0x3d, 0x84, 0x71, 0x56, 0x38, 0x39, 0xee, 0xc1, 0xcb, 0xb2, 0xe1, 0x63, 0x97, 0x65, 0x5e,
12148         0x02, 0x5d, 0x0d, 0x21, 0xe1, 0x08, 0x72, 0x4a, 0x19, 0x58, 0x7c, 0xd6, 0x65, 0xa0, 0xfc, 0x85,
12149         0x04, 0xe3, 0xfe, 0x36, 0x9d, 0x42, 0xd1, 0xb6, 0x1e, 0x2e, 0xda, 0x5e, 0xca, 0xec, 0xa2, 0x29,
12150         0x55, 0xdb, 0xef, 0x58, 0x81, 0xef, 0x31, 0xb1, 0x03, 0xbe, 0xad, 0xb4, 0xf6, 0xd0, 0x25, 0x28,
12151         0xe8, 0x4a, 0xd7, 0xf5, 0x4c, 0xef, 0xb0, 0xac, 0x2b, 0x5d, 0x82, 0x39, 0x05, 0x7d, 0x2a, 0x01,
12152         0x12, 0x59, 0x60, 0x41, 0xd7, 0x0d, 0xaa, 0x38, 0xb1, 0xd2, 0x31, 0x6b, 0x25, 0xb3, 0x59, 0xae,
12153         0xc6, 0xea, 0x56, 0x0c, 0xeb, 0xae, 0x4e, 0xad, 0xbe, 0xbf, 0x23, 0x71, 0x06, 0x9c, 0x60, 0x00,
12154         0x52, 0x00, 0x2c, 0x81, 0xb9, 0x69, 0x88, 0x83, 0x7c, 0x2d, 0x43, 0xcc, 0x63, 0x02, 0x8b, 0x86,
12155         0xbe, 0xa3, 0x76, 0xfc, 0xb0, 0x83, 0x3d, 0x20, 0x1c, 0x00, 0x3d, 0x7f, 0x17, 0xe6, 0x52, 0xac,
12156         0x45, 0x93, 0x90, 0xdf, 0x23, 0x7d, 0x67, 0xd9, 0x30, 0xfb, 0x13, 0xcd, 0xc0, 0xd0, 0xbe, 0xa2,
12157         0xf5, 0x9c, 0xf0, 0x3b, 0x82, 0x9d, 0x1f, 0x6f, 0xe4, 0x6e, 0x4b, 0xf2, 0xe7, 0x43, 0x41, 0xdf,
12158         0xe1, 0x15, 0xf3, 0x15, 0xf6, 0xd1, 0x6a, 0x6a, 0x6a, 0x4b, 0xb1, 0x45, 0x21, 0x74, 0xd6, 0xf9,
12159         0x60, 0x75, 0xc6, 0xb0, 0x47, 0x0d, 0xd5, 0xd6, 0xb9, 0x67, 0x5b, 0x5b, 0xe7, 0x9f, 0x4e, 0x6d,
12160         0xfd, 0xf7, 0x50, 0xb2, 0xdd, 0xaa, 0xba, 0xc0, 0x21, 0xaf, 0x1f, 0x23, 0xbe, 0x8a, 0x82, 0xda,
12161         0x53, 0xe0, 0x95, 0xd2, 0x1e, 0x68, 0x52, 0x11, 0x3d, 0x74, 0xcc, 0x22, 0xfa, 0xa9, 0x16, 0xbe,
12162         0x2c, 0xa6, 0x9a, 0x4a, 0xcf, 0x26, 0x6d, 0x1e, 0x88, 0x4a, 0x7e, 0x4c, 0x6d, 0xf0, 0x51, 0x2c,
12163         0xa8, 0xe8, 0x83, 0x90, 0xcb, 0x96, 0x4e, 0xe2, 0xb2, 0xe3, 0xe9, 0xee, 0x8a, 0xb6, 0x60, 0xce,
12164         0xb4, 0x8c, 0x8e, 0x45, 0x6c, 0x7b, 0x89, 0x28, 0x6d, 0x4d, 0xd5, 0x89, 0xbb, 0x3e, 0x4e, 0x45,
12165         0x74, 0xe1, 0xe8, 0xb0, 0x32, 0xd7, 0x48, 0x66, 0xc1, 0x69, 0xb2, 0xf2, 0xa3, 0x02, 0x4c, 0x46,
12166         0x33, 0x60, 0x4a, 0x91, 0x2a, 0x9d, 0xa8, 0x48, 0xbd, 0x1a, 0x38, 0x0c, 0x4e, 0x05, 0x1f, 0xb8,
12167         0xc1, 0x89, 0x1d, 0x88, 0x05, 0x98, 0x10, 0xd1, 0xc0, 0x25, 0x8a, 0x32, 0xdd, 0xdb, 0xfd, 0xad,
12168         0x30, 0x19, 0x47, 0xf9, 0x59, 0xe9, 0xe9, 0x57, 0x94, 0x2e, 0x48, 0x21, 0x5c, 0x7a, 0x2e, 0x44,
12169         0x19, 0x70, 0x5c, 0x06, 0xad, 0xc1, 0x74, 0x4f, 0x8f, 0x43, 0x39, 0xde, 0x78, 0x41, 0x40, 0x4d,
12170         0x6f, 0xc5, 0x59, 0x70, 0x92, 0x1c, 0xda, 0x09, 0x55, 0xa3, 0xc3, 0x3c, 0xc2, 0xde, 0xc8, 0x7c,
12171         0x76, 0x32, 0x97, 0xa3, 0xe8, 0x0e, 0x8c, 0x59, 0xfc, 0xbb, 0xc3, 0x35, 0xd8, 0xa9, 0xdd, 0xcf,
12172         0x09, 0xb1, 0x31, 0x1c, 0x24, 0xe2, 0x30, 0x6f, 0x42, 0xb9, 0x5d, 0xca, 0x5a, 0x6e, 0xcb, 0x3f,
12173         0x93, 0x82, 0x49, 0xc8, 0x2b, 0x81, 0x07, 0xdd, 0x32, 0xc5, 0x24, 0x02, 0xd5, 0x91, 0x91, 0x5c,
12174         0xfd, 0xde, 0x3a, 0x56, 0xf5, 0xeb, 0x27, 0xcf, 0xc1, 0xe5, 0xef, 0x67, 0x12, 0xcc, 0x2e, 0x37,
12175         0xef, 0x59, 0x46, 0xcf, 0x74, 0xcd, 0xd9, 0x30, 0x9d, 0x75, 0x7d, 0x1d, 0x0a, 0x56, 0x4f, 0x73,
12176         0xe7, 0xf1, 0xa2, 0x3b, 0x0f, 0xdc, 0xd3, 0xd8, 0x3c, 0xa6, 0x23, 0x52, 0xce, 0x24, 0x98, 0x00,
12177         0x5a, 0x87, 0x61, 0x4b, 0xd1, 0x3b, 0xc4, 0x4d, 0xab, 0x97, 0x07, 0x58, 0xbf, 0xb2, 0x84, 0x19,
12178         0x7b, 0xa0, 0x78, 0xe3, 0xd2, 0x58, 0xa0, 0xc8, 0xff, 0x2e, 0xc1, 0xc4, 0xfd, 0xcd, 0xcd, 0xc6,
12179         0x8a, 0xce, 0x4f, 0x34, 0xbf, 0x5b, 0xbd, 0x04, 0x05, 0x53, 0xa1, 0xbb, 0xd1, 0x4c, 0xcf, 0x68,
12180         0x98, 0x53, 0xd0, 0x7b, 0x50, 0x64, 0x91, 0x84, 0xe8, 0xed, 0x8c, 0xa5, 0xb6, 0x80, 0xaf, 0x3b,
12181         0x42, 0x7e, 0x85, 0x28, 0x06, 0xb0, 0x0b, 0x27, 0xef, 0xc1, 0x4c, 0xc0, 0x1c, 0xb6, 0x1e, 0x0f,
12182         0x58, 0x76, 0x44, 0x4d, 0x18, 0x62, 0x9a, 0x59, 0x0e, 0xcc, 0x67, 0xb8, 0xcc, 0x8c, 0x4c, 0xc9,
12183         0xaf, 0x74, 0xd8, 0x2f, 0x1b, 0x3b, 0x58, 0xf2, 0x1a, 0x8c, 0xf1, 0x0b, 0x65, 0xc3, 0xa2, 0x7c,
12184         0x59, 0xd0, 0x45, 0xc8, 0x77, 0x55, 0x5d, 0xe4, 0xd9, 0x51, 0x21, 0x93, 0x67, 0x39, 0x82, 0x8d,
12185         0x73, 0xb2, 0x72, 0x20, 0x22, 0x8f, 0x4f, 0x56, 0x0e, 0x30, 0x1b, 0x97, 0xef, 0x41, 0x51, 0x2c,
12186         0x77, 0x10, 0x28, 0xff, 0x64, 0xa0, 0x7c, 0x02, 0xd0, 0x06, 0x14, 0x57, 0x1a, 0x75, 0xcd, 0x70,
12187         0xaa, 0xae, 0x96, 0xda, 0xb6, 0xa2, 0x7b, 0xb1, 0xb8, 0xb2, 0x84, 0x31, 0xa7, 0x20, 0x19, 0x86,
12188         0xc9, 0x41, 0x8b, 0x98, 0x94, 0x7b, 0xc4, 0x48, 0x1d, 0xd8, 0x2e, 0xdf, 0xe5, 0x23, 0x58, 0x50,
12189         0xe4, 0xff, 0xc8, 0x41, 0x51, 0x2c, 0xc7, 0x29, 0x7c, 0x85, 0xad, 0x86, 0xbe, 0xc2, 0x5e, 0xce,
12190         0xe6, 0x1a, 0xa9, 0x9f, 0x60, 0x9b, 0x91, 0x4f, 0xb0, 0xab, 0x19, 0xf1, 0x9e, 0xfc, 0xfd, 0xf5,
12191         0x63, 0x09, 0xc6, 0xc3, 0x4e, 0x89, 0x6e, 0xc2, 0x28, 0x4b, 0x38, 0x6a, 0x8b, 0xac, 0xfb, 0x75,
12192         0xae, 0x77, 0x09, 0xd3, 0xf4, 0x49, 0x38, 0xc8, 0x87, 0x3a, 0x9e, 0x18, 0xf3, 0x23, 0x31, 0xe9,
12193         0xf4, 0x25, 0xed, 0x51, 0x55, 0xab, 0x3a, 0x8f, 0x24, 0xd5, 0x15, 0x9d, 0x6e, 0x58, 0x4d, 0x6a,
12194         0xa9, 0x7a, 0x27, 0xa6, 0x88, 0x3b, 0x65, 0x10, 0x59, 0xfe, 0xa9, 0x04, 0xa3, 0xc2, 0xe4, 0x53,
12195         0xf8, 0xaa, 0xf8, 0x9b, 0xf0, 0x57, 0xc5, 0xe5, 0x8c, 0x07, 0x3c, 0xf9, 0x93, 0xe2, 0xff, 0x7d,
12196         0xd3, 0xd9, 0x91, 0x66, 0x5e, 0xbd, 0x6b, 0xd8, 0x34, 0xea, 0xd5, 0xec, 0x30, 0x62, 0x4e, 0x41,
12197         0x3d, 0x98, 0x54, 0x23, 0x31, 0x40, 0x2c, 0x6d, 0x2d, 0x9b, 0x25, 0x9e, 0x58, 0xbd, 0x2c, 0xe0,
12198         0x27, 0xa3, 0x14, 0x1c, 0x53, 0x21, 0x13, 0x88, 0x71, 0xa1, 0x77, 0xa1, 0xb0, 0x4b, 0xa9, 0x99,
12199         0x70, 0x5f, 0x3d, 0x20, 0xf2, 0xf8, 0x26, 0x94, 0xf8, 0xec, 0x36, 0x37, 0x1b, 0x98, 0x43, 0xc9,
12200         0xbf, 0xf7, 0xd7, 0xa3, 0xe9, 0xf8, 0xb8, 0x17, 0x4f, 0xa5, 0x93, 0xc4, 0xd3, 0xd1, 0xa4, 0x58,
12201         0x8a, 0xee, 0x43, 0x9e, 0x6a, 0x59, 0x3f, 0x0b, 0x05, 0xe2, 0xe6, 0x6a, 0xd3, 0x0f, 0x48, 0x9b,
12202         0xab, 0x4d, 0xcc, 0x20, 0xd0, 0x06, 0x0c, 0xb1, 0xec, 0xc3, 0x8e, 0x60, 0x3e, 0xfb, 0x91, 0x66,
12203         0xf3, 0xf7, 0x1d, 0x82, 0xfd, 0xb2, 0xb1, 0x83, 0x23, 0x7f, 0x0c, 0x63, 0xa1, 0x73, 0x8a, 0x3e,
12204         0x82, 0xb3, 0x9a, 0xa1, 0xb4, 0xeb, 0x8a, 0xa6, 0xe8, 0x2d, 0xe2, 0x3e, 0x0e, 0x5c, 0x4e, 0xfa,
12205         0xc2, 0x58, 0x0d, 0xf0, 0x89, 0x53, 0x3e, 0x23, 0x94, 0x9c, 0x0d, 0xd2, 0x70, 0x08, 0x51, 0x56,
12206         0x00, 0xfc, 0x39, 0xa2, 0x0a, 0x0c, 0x31, 0x3f, 0x73, 0xf2, 0xc9, 0x48, 0x7d, 0x84, 0x59, 0xc8,
12207         0xdc, 0xcf, 0xc6, 0xce, 0x38, 0xba, 0x01, 0x60, 0x93, 0x96, 0x45, 0x28, 0x0f, 0x06, 0xb9, 0xf0,
12208         0x03, 0x63, 0xd3, 0xa3, 0xe0, 0x00, 0x97, 0xfc, 0x73, 0x09, 0xc6, 0xd6, 0x09, 0xfd, 0xc4, 0xb0,
12209         0xf6, 0x1a, 0x86, 0xa6, 0xb6, 0xfa, 0xa7, 0x10, 0x6c, 0x71, 0x28, 0xd8, 0xbe, 0x32, 0x60, 0x67,
12210         0x42, 0xd6, 0xa5, 0x85, 0x5c, 0xf9, 0x0b, 0x09, 0xe6, 0x42, 0x9c, 0x77, 0xfd, 0xa3, 0xbb, 0x05,
12211         0x43, 0xa6, 0x61, 0x51, 0x37, 0x11, 0x1f, 0x4b, 0x21, 0x0b, 0x63, 0x81, 0x54, 0xcc, 0x60, 0xb0,
12212         0x83, 0x86, 0x56, 0x21, 0x47, 0x0d, 0xe1, 0xaa, 0xc7, 0xc3, 0x24, 0xc4, 0xaa, 0x83, 0xc0, 0xcc,
12213         0x6d, 0x1a, 0x38, 0x47, 0x0d, 0xb6, 0x11, 0xe5, 0x10, 0x57, 0x30, 0xf8, 0x3c, 0xa3, 0x19, 0x60,
12214         0x28, 0xec, 0x58, 0x46, 0xf7, 0xc4, 0x73, 0xf0, 0x36, 0x62, 0xd9, 0x32, 0xba, 0x98, 0x63, 0xc9,
12215         0x5f, 0x4a, 0x30, 0x15, 0xe2, 0x3c, 0x85, 0xc0, 0xff, 0x6e, 0x38, 0xf0, 0x5f, 0x3d, 0xce, 0x44,
12216         0x52, 0xc2, 0xff, 0x97, 0xb9, 0xc8, 0x34, 0xd8, 0x84, 0xd1, 0x0e, 0x8c, 0x9a, 0x46, 0xbb, 0xf9,
12217         0x14, 0x9e, 0x03, 0x27, 0x58, 0xde, 0x6c, 0xf8, 0x58, 0x38, 0x08, 0x8c, 0x0e, 0x60, 0x4a, 0x57,
12218         0xba, 0xc4, 0x36, 0x95, 0x16, 0x69, 0x3e, 0x85, 0x0b, 0x92, 0x73, 0xfc, 0xbd, 0x21, 0x8a, 0x88,
12219         0xe3, 0x4a, 0xd0, 0x1a, 0x14, 0x55, 0x93, 0xd7, 0x71, 0xa2, 0x76, 0x19, 0x98, 0x45, 0x9d, 0xaa,
12220         0xcf, 0x89, 0xe7, 0xe2, 0x07, 0x76, 0x31, 0xe4, 0x1f, 0x44, 0xbd, 0x81, 0xf9, 0x1f, 0xba, 0x07,
12221         0x25, 0xde, 0x62, 0xd1, 0x32, 0x34, 0xf7, 0x65, 0x80, 0xed, 0x6c, 0x43, 0x8c, 0x3d, 0x3e, 0xac,
12222         0x5c, 0x48, 0xb8, 0xf4, 0x75, 0xc9, 0xd8, 0x13, 0x46, 0xeb, 0x50, 0x30, 0xbf, 0x4f, 0x05, 0xc3,
12223         0x93, 0x1c, 0x2f, 0x5b, 0x38, 0x8e, 0xfc, 0x4f, 0xf9, 0x88, 0xb9, 0x3c, 0xd5, 0x3d, 0x7c, 0x6a,
12224         0xbb, 0xee, 0x55, 0x4c, 0xa9, 0x3b, 0xbf, 0x0d, 0x45, 0x91, 0xe1, 0x85, 0x33, 0xbf, 0x7e, 0x1c,
12225         0x67, 0x0e, 0x66, 0x31, 0xef, 0x83, 0xc5, 0x1d, 0x74, 0x81, 0xd1, 0x87, 0x30, 0x4c, 0x1c, 0x15,
12226         0x4e, 0x6e, 0xbc, 0x75, 0x1c, 0x15, 0x7e, 0x5c, 0xf5, 0x0b, 0x55, 0x31, 0x26, 0x50, 0xd1, 0x5b,
12227         0x6c, 0xbd, 0x18, 0x2f, 0xfb, 0x08, 0xb4, 0xcb, 0x05, 0x9e, 0xae, 0x2e, 0x3a, 0xd3, 0xf6, 0x86,
12228         0x1f, 0x1f, 0x56, 0xc0, 0xff, 0x89, 0x83, 0x12, 0xf2, 0x2f, 0x25, 0x98, 0xe2, 0x2b, 0xd4, 0xea,
12229         0x59, 0x2a, 0xed, 0x9f, 0x5a, 0x62, 0x7a, 0x10, 0x4a, 0x4c, 0xaf, 0x0d, 0x58, 0x96, 0x98, 0x85,
12230         0xa9, 0xc9, 0xe9, 0x2b, 0x09, 0xce, 0xc5, 0xb8, 0x4f, 0x21, 0x2e, 0x6e, 0x85, 0xe3, 0xe2, 0x2b,
12231         0xc7, 0x9d, 0x50, 0x4a, 0x6c, 0xfc, 0xe7, 0xc9, 0x84, 0xe9, 0xf0, 0x93, 0x72, 0x03, 0xc0, 0xb4,
12232         0xd4, 0x7d, 0x55, 0x23, 0x1d, 0xf1, 0x08, 0x5e, 0x0a, 0xb4, 0x38, 0x79, 0x14, 0x1c, 0xe0, 0x42,
12233         0x36, 0xcc, 0xb6, 0xc9, 0x8e, 0xd2, 0xd3, 0xe8, 0x42, 0xbb, 0xbd, 0xa8, 0x98, 0xca, 0xb6, 0xaa,
12234         0xa9, 0x54, 0x15, 0xd7, 0x05, 0x23, 0xf5, 0x3b, 0xce, 0xe3, 0x74, 0x12, 0xc7, 0xe3, 0xc3, 0xca,
12235         0xc5, 0xa4, 0xd7, 0x21, 0x97, 0xa5, 0x8f, 0x53, 0xa0, 0x51, 0x1f, 0xca, 0x16, 0xf9, 0xb8, 0xa7,
12236         0x5a, 0xa4, 0xbd, 0x64, 0x19, 0x66, 0x48, 0x6d, 0x9e, 0xab, 0xfd, 0xeb, 0xa3, 0xc3, 0x4a, 0x19,
12237         0xa7, 0xf0, 0x0c, 0x56, 0x9c, 0x0a, 0x8f, 0x1e, 0xc2, 0xb4, 0xe2, 0x74, 0x86, 0x85, 0xb4, 0x3a,
12238         0xa7, 0xe4, 0xf6, 0xd1, 0x61, 0x65, 0x7a, 0x21, 0x4e, 0x1e, 0xac, 0x30, 0x09, 0x14, 0xd5, 0xa0,
12239         0xb8, 0xcf, 0xfb, 0xd6, 0xec, 0xf2, 0x10, 0xc7, 0x67, 0x89, 0xa0, 0xe8, 0xb4, 0xb2, 0x31, 0xcc,
12240         0xe1, 0xe5, 0x26, 0x3f, 0x7d, 0x2e, 0x17, 0xfb, 0xa0, 0x64, 0xb5, 0xa4, 0x38, 0xf1, 0xfc, 0xc6,
12241         0xb8, 0xe4, 0x47, 0xad, 0xfb, 0x3e, 0x09, 0x07, 0xf9, 0xd0, 0x07, 0x30, 0xb2, 0x2b, 0x6e, 0x25,
12242         0xec, 0x72, 0x31, 0x53, 0x12, 0x0e, 0xdd, 0x62, 0xd4, 0xa7, 0x84, 0x8a, 0x11, 0x77, 0xd8, 0xc6,
12243         0x3e, 0x22, 0x7a, 0x09, 0x8a, 0xfc, 0xc7, 0xca, 0x12, 0xbf, 0x8e, 0x2b, 0xf9, 0xb1, 0xed, 0xbe,
12244         0x33, 0x8c, 0x5d, 0xba, 0xcb, 0xba, 0xd2, 0x58, 0xe4, 0xd7, 0xc2, 0x11, 0xd6, 0x95, 0xc6, 0x22,
12245         0x76, 0xe9, 0xe8, 0x23, 0x28, 0xda, 0x64, 0x55, 0xd5, 0x7b, 0x07, 0x65, 0xc8, 0xf4, 0xa8, 0xdc,
12246         0xbc, 0xcb, 0xb9, 0x23, 0x17, 0x63, 0xbe, 0x06, 0x41, 0xc7, 0x2e, 0x2c, 0xda, 0x85, 0x11, 0xab,
12247         0xa7, 0x2f, 0xd8, 0x5b, 0x36, 0xb1, 0xca, 0xa3, 0x5c, 0xc7, 0xa0, 0x70, 0x8e, 0x5d, 0xfe, 0xa8,
12248         0x16, 0x6f, 0x85, 0x3c, 0x0e, 0xec, 0x83, 0xa3, 0x7f, 0x93, 0x00, 0xd9, 0x3d, 0xd3, 0xd4, 0x48,
12249         0x97, 0xe8, 0x54, 0xd1, 0xf8, 0x5d, 0x9c, 0x5d, 0x3e, 0xcb, 0x75, 0xbe, 0x3d, 0x68, 0x5e, 0x31,
12250         0xc1, 0xa8, 0x72, 0xef, 0xd2, 0x3b, 0xce, 0x8a, 0x13, 0xf4, 0xb2, 0xa5, 0xdd, 0xb1, 0xf9, 0xdf,
12251         0xe5, 0xb1, 0x4c, 0x4b, 0x9b, 0x7c, 0xe7, 0xe8, 0x2f, 0xad, 0xa0, 0x63, 0x17, 0x16, 0x3d, 0x80,
12252         0x59, 0xb7, 0xed, 0x11, 0x1b, 0x06, 0x5d, 0x56, 0x35, 0x62, 0xf7, 0x6d, 0x4a, 0xba, 0xe5, 0x71,
12253         0xbe, 0xed, 0x5e, 0xef, 0x07, 0x4e, 0xe4, 0xc2, 0x29, 0xd2, 0xa8, 0x0b, 0x15, 0x37, 0x64, 0xb0,
12254         0xf3, 0xe4, 0xc5, 0xac, 0xbb, 0x76, 0x4b, 0xd1, 0x9c, 0x77, 0x80, 0x09, 0xae, 0xe0, 0xc5, 0xa3,
12255         0xc3, 0x4a, 0x65, 0xe9, 0xc9, 0xac, 0x78, 0x10, 0x16, 0x7a, 0x0f, 0xca, 0x4a, 0x9a, 0x9e, 0x49,
12256         0xae, 0xe7, 0x79, 0x16, 0x87, 0x52, 0x15, 0xa4, 0x4a, 0x23, 0x0a, 0x93, 0x4a, 0xb8, 0x01, 0xd5,
12257         0x2e, 0x4f, 0x65, 0xba, 0x88, 0x8c, 0xf4, 0xad, 0xfa, 0x97, 0x11, 0x11, 0x82, 0x8d, 0x63, 0x1a,
12258         0xd0, 0x3f, 0x00, 0x52, 0xa2, 0x3d, 0xb3, 0x76, 0x19, 0x65, 0x4a, 0x3f, 0xb1, 0x66, 0x5b, 0xdf,
12259         0xed, 0x62, 0x24, 0x1b, 0x27, 0xe8, 0x41, 0xab, 0x30, 0x23, 0x46, 0xb7, 0x74, 0x5b, 0xd9, 0x21,
12260         0xcd, 0xbe, 0xdd, 0xa2, 0x9a, 0x5d, 0x9e, 0xe6, 0xb1, 0x8f, 0x3f, 0x7c, 0x2d, 0x24, 0xd0, 0x71,
12261         0xa2, 0x14, 0x7a, 0x1b, 0x26, 0x77, 0x0c, 0x6b, 0x5b, 0x6d, 0xb7, 0x89, 0xee, 0x22, 0xcd, 0x70,
12262         0xa4, 0x19, 0xb6, 0x1a, 0xcb, 0x11, 0x1a, 0x8e, 0x71, 0x23, 0x1b, 0xce, 0x09, 0xe4, 0x86, 0x65,
12263         0xb4, 0xd6, 0x8c, 0x9e, 0x4e, 0x9d, 0x92, 0xe8, 0x9c, 0x97, 0x62, 0xce, 0x2d, 0x24, 0x31, 0x3c,
12264         0x3e, 0xac, 0x5c, 0x4a, 0xae, 0x80, 0x7d, 0x26, 0x9c, 0x8c, 0x8d, 0x76, 0x01, 0x78, 0x5c, 0x70,
12265         0x8e, 0xdf, 0x2c, 0x3f, 0x7e, 0xb7, 0xb3, 0x44, 0x9d, 0xc4, 0x13, 0xe8, 0x3c, 0xc9, 0x79, 0x64,
12266         0x1c, 0xc0, 0xe6, 0xbd, 0x32, 0xe2, 0xe5, 0xe4, 0x74, 0xfa, 0x8d, 0x8f, 0xd7, 0x2b, 0xe3, 0x9b,
12267         0xf6, 0xd4, 0x7a, 0x65, 0x02, 0x90, 0x4f, 0xbe, 0xab, 0xfd, 0x6d, 0x0e, 0xa6, 0x7d, 0xe6, 0xcc,
12268         0xbd, 0x32, 0x09, 0x22, 0x7f, 0xee, 0x39, 0x1e, 0xdc, 0x73, 0xfc, 0x85, 0x04, 0xe3, 0xfe, 0xd2,
12269         0xfd, 0xf1, 0xf5, 0xaf, 0xf8, 0xb6, 0xa5, 0x54, 0xd4, 0x3f, 0xca, 0x05, 0x27, 0xf0, 0x27, 0xdf,
12270         0x44, 0xf1, 0xfd, 0x1b, 0x85, 0xe5, 0xaf, 0xf2, 0x30, 0x19, 0x3d, 0x8d, 0xa1, 0xb7, 0x76, 0x69,
12271         0xe0, 0x5b, 0x7b, 0x03, 0x66, 0x76, 0x7a, 0x9a, 0xd6, 0xe7, 0xcb, 0x10, 0x78, 0x70, 0x77, 0xde,
12272         0xca, 0x9e, 0x17, 0x92, 0x33, 0xcb, 0x09, 0x3c, 0x38, 0x51, 0x32, 0xa5, 0x6f, 0x20, 0x7f, 0xa2,
12273         0xbe, 0x81, 0xd8, 0x33, 0x76, 0xe1, 0x18, 0xcf, 0xd8, 0x89, 0x3d, 0x00, 0x43, 0x27, 0xe8, 0x01,
12274         0x38, 0xc9, 0xa3, 0x7d, 0x42, 0x10, 0x1b, 0xd8, 0x43, 0xfa, 0x3c, 0x9c, 0x17, 0x62, 0x94, 0xbf,
12275         0xa7, 0xeb, 0xd4, 0x32, 0x34, 0x8d, 0x58, 0x4b, 0xbd, 0x6e, 0xb7, 0x2f, 0xbf, 0x09, 0xe3, 0xe1,
12276         0x4e, 0x11, 0x67, 0xa7, 0x9d, 0x66, 0x15, 0xf1, 0x62, 0x19, 0xd8, 0x69, 0x67, 0x1c, 0x7b, 0x1c,
12277         0xf2, 0xbf, 0x48, 0x30, 0x9b, 0xdc, 0x11, 0x8a, 0x34, 0x18, 0xef, 0x2a, 0x07, 0xc1, 0x2e, 0x5d,
12278         0xe9, 0x84, 0x77, 0x49, 0xbc, 0x45, 0x60, 0x2d, 0x84, 0x85, 0x23, 0xd8, 0xf2, 0x77, 0x12, 0xcc,
12279         0xa5, 0x3c, 0xce, 0x9f, 0xae, 0x25, 0xe8, 0x7d, 0x28, 0x75, 0x95, 0x83, 0x66, 0xcf, 0xea, 0x90,
12280         0x13, 0xdf, 0x9e, 0xf1, 0x88, 0xb1, 0x26, 0x50, 0xb0, 0x87, 0x27, 0xff, 0x9f, 0x04, 0xcf, 0xa5,
12281         0x56, 0x14, 0xe8, 0x56, 0xa8, 0x8f, 0x40, 0x8e, 0xf4, 0x11, 0xa0, 0xb8, 0xe0, 0x33, 0x6a, 0x23,
12282         0xf8, 0x4c, 0x82, 0x72, 0xda, 0xd7, 0x16, 0xba, 0x19, 0x32, 0xf2, 0x85, 0x88, 0x91, 0x53, 0x31,
12283         0xb9, 0x67, 0x64, 0xe3, 0x0f, 0x25, 0x98, 0x4d, 0xfe, 0xea, 0x44, 0xaf, 0x86, 0x2c, 0xac, 0x44,
12284         0x2c, 0x9c, 0x88, 0x48, 0x09, 0xfb, 0x3e, 0x84, 0x71, 0xf1, 0x6d, 0x2a, 0x60, 0xc4, 0xde, 0xcb,
12285         0x49, 0x11, 0x5d, 0x40, 0xb8, 0x95, 0x20, 0xf7, 0xaa, 0xf0, 0x18, 0x8e, 0xa0, 0xc9, 0xff, 0x9a,
12286         0x83, 0xa1, 0x66, 0x4b, 0xd1, 0xc8, 0x29, 0x14, 0x83, 0xef, 0x84, 0x8a, 0xc1, 0x41, 0xff, 0xf7,
12287         0xc3, 0xad, 0x4a, 0xad, 0x03, 0x71, 0xa4, 0x0e, 0x7c, 0x39, 0x13, 0xda, 0x93, 0x4b, 0xc0, 0xbf,
12288         0x82, 0x11, 0x4f, 0xe9, 0xf1, 0x32, 0x93, 0xfc, 0xbf, 0x39, 0x18, 0x0d, 0xa8, 0x38, 0x66, 0x5e,
12289         0xdb, 0x09, 0xd5, 0x03, 0xf9, 0x0c, 0xe5, 0x7f, 0x40, 0x57, 0xd5, 0xad, 0x00, 0x9c, 0xbe, 0x55,
12290         0xbf, 0x53, 0x31, 0x5e, 0x18, 0xbc, 0x09, 0xe3, 0x54, 0xb1, 0x3a, 0x84, 0x7a, 0x37, 0xe3, 0x79,
12291         0xee, 0x8b, 0x5e, 0xb7, 0xf3, 0x66, 0x88, 0x8a, 0x23, 0xdc, 0xe7, 0xef, 0xc0, 0x58, 0x48, 0xd9,
12292         0xb1, 0xda, 0x4e, 0x7f, 0x22, 0xc1, 0x0b, 0x03, 0xef, 0x2d, 0x50, 0x3d, 0x74, 0x48, 0xaa, 0x91,
12293         0x43, 0x32, 0x9f, 0x0e, 0xf0, 0xec, 0xda, 0x97, 0xea, 0xd7, 0x1e, 0x7d, 0x3b, 0x7f, 0xe6, 0xeb,
12294         0x6f, 0xe7, 0xcf, 0x7c, 0xf3, 0xed, 0xfc, 0x99, 0x7f, 0x3c, 0x9a, 0x97, 0x1e, 0x1d, 0xcd, 0x4b,
12295         0x5f, 0x1f, 0xcd, 0x4b, 0xdf, 0x1c, 0xcd, 0x4b, 0xbf, 0x3e, 0x9a, 0x97, 0xfe, 0xf3, 0xbb, 0xf9,
12296         0x33, 0xef, 0x17, 0x05, 0xdc, 0x1f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x51, 0x7e, 0x9f, 0x62, 0x14,
12297         0x3c, 0x00, 0x00,
12298 }