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